Merge pull request #2 from SuperQ/sources_collector

Add sources collector

Author: SuperQ

CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 / 2022-03-20
+
+Initial release.

README.md

@@ -1,2 +1,53 @@
-# chrony_exporter
-Exporter for Chrony NTP
+# Prometheus Chrony Exporter
+
+[![Build Status](https://circleci.com/gh/superq/chrony_exporter.svg?style=svg)](https://circleci.com/gh/superq/chrony_exporter)
+
+This is a [Prometheus Exporter](https://prometheus.io) for [Chrony NTP](https://chrony.tuxfamily.org/).
+
+## Installation
+
+For most use-cases, simply download the [the latest
+release](https://github.com/superq/chrony_exporter/releases).
+
+### Building from source
+
+You need a Go development environment. Then, simply run `make` to build the
+executable:
+
+    make
+
+This uses the common prometheus tooling to build and run some tests.
+
+### Building a Docker container
+
+You can build a Docker container with the included `docker` make target:
+
+    make promu
+    promu crossbuild -p linux/amd64 -p linux/arm64
+    make docker
+
+This will not even require Go tooling on the host.
+
+## Running
+
+A minimal invocation looks like this:
+
+    ./chrony_exporter
+
+Supported parameters include:
+
+- `--web.listen-address`: the address/port to listen on (default: `":9290"`)
+- `--collector.sources`: Enable/disable the collection of `chronyc sources` metrics. (Default: Disabled)
+- `--collector.tracking`: Enable/disable the collection of `chronyc tracking` metrics. (Default: Enabled)
+
+To disable a collector, use `--no-`. (i.e. `--no-collector.tracking`)
+
+By default, the exporter will bind on `:9123`.
+
+## TLS and basic authentication
+
+The IPMI Exporter supports TLS and basic authentication.
+
+To use TLS and/or basic authentication, you need to pass a configuration file
+using the `--web.config.file` parameter. The format of the file is described
+[in the exporter-toolkit repository](https://github.com/prometheus/exporter-toolkit/blob/master/docs/web-configuration.md).

VERSION

@@ -0,0 +1 @@
+0.1.1

collector/collector.go

@@ -21,18 +21,27 @@ import (
 	"github.com/go-kit/log"
 	"github.com/go-kit/log/level"
 	"github.com/prometheus/client_golang/prometheus"
+	"gopkg.in/alecthomas/kingpin.v2"
 )
 
 const (
 	namespace = "chrony"
 )
 
+var (
+	collectTracking = kingpin.Flag("collector.tracking", "Collect tracking metrics").Default("true").Bool()
+	collectSources  = kingpin.Flag("collector.sources", "Collect sources metrics").Default("false").Bool()
+)
+
 // Exporter collects chrony stats from the given server and exports
 // them using the prometheus metrics package.
 type Exporter struct {
 	address string
 	timeout time.Duration
 
+	collectSources  bool
+	collectTracking bool
+
 	logger log.Logger
 }
 
@@ -46,10 +55,15 @@ func (d *typedDesc) mustNewConstMetric(value float64, labels ...string) promethe
 }
 
 func NewExporter(address string, logger log.Logger) Exporter {
+
 	return Exporter{
 		address: address,
 		timeout: 5 * time.Second,
-		logger:  logger,
+
+		collectSources:  *collectSources,
+		collectTracking: *collectTracking,
+
+		logger: logger,
 	}
 }
 
@@ -67,5 +81,11 @@ func (e Exporter) Collect(ch chan<- prometheus.Metric) {
 
 	client := chrony.Client{Sequence: 1, Connection: conn}
 
-	e.getTrackingMetrics(ch, client)
+	if e.collectSources {
+		e.getSourcesMetrics(ch, client)
+	}
+
+	if e.collectTracking {
+		e.getTrackingMetrics(ch, client)
+	}
 }

collector/sources.go

@@ -0,0 +1,150 @@
+// Copyright 2022 Ben Kochie
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package collector
+
+import (
+	"fmt"
+	"math"
+	"net"
+	"strings"
+
+	"github.com/facebook/time/ntp/chrony"
+	"github.com/go-kit/log/level"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+const (
+	sourcesSubsystem = "sources"
+)
+
+var (
+	sourcesLastRx = typedDesc{
+		prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, sourcesSubsystem, "last_sample_age_seconds"),
+			"Chrony sources last good sample age in seconds",
+			[]string{"source_address", "source_name"},
+			nil,
+		),
+		prometheus.GaugeValue,
+	}
+
+	sourcesLastSample = typedDesc{
+		prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, sourcesSubsystem, "last_sample_offset_seconds"),
+			"Chrony sources last sample margin of error in seconds",
+			[]string{"source_address", "source_name"},
+			nil,
+		),
+		prometheus.GaugeValue,
+	}
+
+	sourcesLastSampleErr = typedDesc{
+		prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, sourcesSubsystem, "last_sample_error_margin_seconds"),
+			"Chrony sources last sample offset in seconds",
+			[]string{"source_address", "source_name"},
+			nil,
+		),
+		prometheus.GaugeValue,
+	}
+
+	sourcesPollInterval = typedDesc{
+		prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, sourcesSubsystem, "polling_interval_seconds"),
+			"Chrony sources polling interval in seconds",
+			[]string{"source_address", "source_name"},
+			nil,
+		),
+		prometheus.GaugeValue,
+	}
+
+	sourcesStateInfo = typedDesc{
+		prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, sourcesSubsystem, "state_info"),
+			"Chrony sources state info",
+			[]string{"source_address", "source_name", "source_state", "source_mode"},
+			nil,
+		),
+		prometheus.GaugeValue,
+	}
+
+	sourcesStratum = typedDesc{
+		prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, sourcesSubsystem, "stratum"),
+			"Chrony sources stratum",
+			[]string{"source_address", "source_name"},
+			nil,
+		),
+		prometheus.GaugeValue,
+	}
+)
+
+func (e Exporter) getSourcesMetrics(ch chan<- prometheus.Metric, client chrony.Client) {
+	packet, err := client.Communicate(chrony.NewSourcesPacket())
+	if err != nil {
+		level.Error(e.logger).Log("msg", "Couldn't get sources", "err", err)
+		return
+	}
+	level.Debug(e.logger).Log("msg", "Got 'sources' response", "sources_packet", packet.GetStatus())
+
+	sources, ok := packet.(*chrony.ReplySources)
+	if !ok {
+		level.Error(e.logger).Log("msg", "Got wrong 'sources' response", "packet", packet)
+		return
+	}
+
+	results := make([]chrony.ReplySourceData, sources.NSources)
+
+	for i := 0; i < int(sources.NSources); i++ {
+		level.Debug(e.logger).Log("msg", "Fetching source", "source", i)
+		packet, err = client.Communicate(chrony.NewSourceDataPacket(int32(i)))
+		if err != nil {
+			level.Error(e.logger).Log("msg", "Failed to get sourcedata response", "source", i)
+			return
+		}
+		sourceData, ok := packet.(*chrony.ReplySourceData)
+		if !ok {
+			level.Error(e.logger).Log("msg", "Got wrong 'sourcedata' response", "packet", packet)
+			return
+		}
+		results[i] = *sourceData
+	}
+
+	for _, r := range results {
+		sourceAddress := r.IPAddr.String()
+		// Ignore reverse lookup errors.
+		sourceNames, _ := net.LookupAddr(sourceAddress)
+		sourceName := strings.Join(sourceNames, ",")
+
+		ch <- sourcesLastRx.mustNewConstMetric(float64(r.SinceSample), sourceAddress, sourceName)
+		ch <- sourcesLastSample.mustNewConstMetric(r.LatestMeas, sourceAddress, sourceName)
+		ch <- sourcesLastSampleErr.mustNewConstMetric(r.LatestMeasErr, sourceAddress, sourceName)
+		ch <- sourcesPollInterval.mustNewConstMetric(math.Pow(2, float64(r.Poll)), sourceAddress, sourceName)
+		ch <- sourcesStateInfo.mustNewConstMetric(1.0, sourceAddress, sourceName, r.State.String(), modeTypeString(r.Mode))
+		ch <- sourcesStratum.mustNewConstMetric(float64(r.Stratum), sourceAddress, sourceName)
+	}
+}
+
+var modeTypeDesc = []string{
+	"client",
+	"peer",
+	"ref",
+}
+
+func modeTypeString(m chrony.ModeType) string {
+	if int(m) >= len(modeTypeDesc) {
+		return fmt.Sprintf("unknown (%d)", m)
+	}
+	return modeTypeDesc[m]
+}

main.go

@@ -51,16 +51,19 @@ func main() {
 	flag.AddFlags(kingpin.CommandLine, promlogConfig)
 	kingpin.CommandLine.UsageWriter(os.Stdout)
 	kingpin.HelpFlag.Short('h')
-	kingpin.Version(version.Print("ipmi_exporter"))
+	kingpin.Version(version.Print("chrony_exporter"))
 	kingpin.Parse()
 
 	logger = promlog.New(promlogConfig)
+	level.Info(logger).Log("msg", "Starting chrony_exporter", "version", version.Info())
+	prometheus.MustRegister(version.NewCollector("chrony_exporter"))
 
 	exporter := collector.NewExporter(*address, logger)
 	prometheus.MustRegister(exporter)
 
 	http.Handle("/metrics", promhttp.Handler())
 
+	level.Info(logger).Log("msg", "Listening on", "address", *listenAddress)
 	srv := &http.Server{Addr: *listenAddress}
 	if err := web.ListenAndServe(srv, *webConfig, logger); err != nil {
 		level.Error(logger).Log("msg", "HTTP listener stopped", "error", err)