rewrite

Author: demurky

.gitignore

@@ -0,0 +1,157 @@
+// Copyright 2023 the netexp authors.
+// SPDX-License-Identifier: MIT
+
+// TODO:
+// - Test netdev.*NetDev.Traffic + $HOST_PROC.
+// - Add proper logging.
+// - Test netdev's logging.
+// - Use layer8co/toolbox/container/ringbuf in netdev instead of []int64 once it's ready.
+// - Implement a generic bucketed pool in layer8co/toolbox and use that in rcu.*BufferRcu instead of sync.Pool.
+// - Move rcu to layer8co/toolbox.
+
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/layer8co/netexp/internal/metrics"
+	"github.com/layer8co/netexp/internal/netdev"
+	"github.com/layer8co/netexp/internal/rcu"
+)
+
+const (
+	appName  = "netexp"
+	helpText = "netexp is a Prometheus exporter that provides advanced network usage metrics."
+)
+
+var (
+	listen = flag.String(
+		"listen",
+		":9298",
+		"address to listen on",
+	)
+	ifaceRegexpFlag = flag.String(
+		"iface-regexp",
+		netdev.IfacePattern,
+		"regexp to match network interface names",
+	)
+	interval = flag.Duration(
+		"interval",
+		time.Second,
+		"polling interval (e.g. 500ms, 1s)",
+	)
+	burstWindowsFlag = flag.String(
+		"burst-windows",
+		"1s,5s",
+		"comma-separated burst window durations",
+	)
+	outputWindowsFlag = flag.String(
+		"output-windows",
+		"15s,30s,60s",
+		"comma-separated output window durations",
+	)
+)
+
+var (
+	appRcu     = rcu.NewBufferRcu()
+	appNetDev  *netdev.NetDev
+	appMetrics *metrics.Metrics
+)
+
+func main() {
+
+	flag.Usage = func() {
+		fmt.Fprintf(flag.CommandLine.Output(), "%s\n\nUsage:\n", helpText)
+		flag.PrintDefaults()
+	}
+
+	flag.Parse()
+
+	ifaceRegexp, err := regexp.Compile(*ifaceRegexpFlag)
+	if err != nil {
+		die(fmt.Sprintf("-iface-regexp parse erorr: %s", err))
+	}
+
+	appNetDev = netdev.New(ifaceRegexp.Match, func(fn func(io.Writer)) {
+		b := new(bytes.Buffer)
+		fn(b)
+		fmt.Printf("%s\n", b.Bytes())
+	})
+
+	appMetrics = metrics.New(metrics.Config{
+		Interval:      *interval,
+		BurstWindows:  mustGet(parseDurations(*burstWindowsFlag)),
+		OutputWindows: mustGet(parseDurations(*outputWindowsFlag)),
+	})
+
+	fmt.Printf("listening on %s\n", *listen)
+
+	go func() {
+		mustDo(gatherMetrics())
+	}()
+
+	serveHttp()
+}
+
+func serveHttp() error {
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintln(w, appName)
+	})
+	http.HandleFunc("/metrics", func(w http.ResponseWriter, r *http.Request) {
+		appRcu.Read(func(b []byte) {
+			w.Write(b)
+		})
+	})
+	return http.ListenAndServe(*listen, nil)
+}
+
+func gatherMetrics() error {
+	for ; true; <-time.Tick(*interval) {
+		recv, trns, err := appNetDev.Traffic()
+		if err != nil {
+			return err
+		}
+		appRcu.Update(func(b []byte) ([]byte, error) {
+			b = appMetrics.Step(recv, trns, b)
+			b = append(b, '\n')
+			return b, nil
+		})
+	}
+	return nil
+}
+
+func parseDurations(s string) (out []time.Duration, err error) {
+	for field := range strings.SplitSeq(s, ",") {
+		field = strings.TrimSpace(field)
+		d, err := time.ParseDuration(field)
+		if err != nil {
+			return nil, fmt.Errorf("could not parse duration %q: %w", field, err)
+		}
+		out = append(out, d)
+	}
+	return out, nil
+}
+
+func die(s string) {
+	fmt.Println(s)
+	os.Exit(1)
+}
+
+func mustDo(err error) {
+	if err != nil {
+		die(err.Error())
+	}
+}
+
+func mustGet[T any](v T, err error) T {
+	mustDo(err)
+	return v
+}

cmd/netexp/main.go

@@ -1,3 +1,15 @@
-module netexp
+module github.com/layer8co/netexp
 
 go 1.25
+
+require (
+	github.com/google/go-cmp v0.7.0
+	github.com/layer8co/toolbox v0.0.0-20251226110524-6a835a85a5f0
+	github.com/stretchr/testify v1.11.1
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.mod

@@ -0,0 +1,14 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/layer8co/toolbox v0.0.0-20251226110524-6a835a85a5f0 h1:vUMx/YkYWE90NarteFC+1khg1ccBoxtEv98HfY7bUJI=
+github.com/layer8co/toolbox v0.0.0-20251226110524-6a835a85a5f0/go.mod h1:hPcuU4E0sSSIS1Zy/I7GAlAXbM0su5lbiKBJGEpvpCE=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

go.sum

@@ -0,0 +1,82 @@
+// Copyright 2023 the netexp authors.
+// SPDX-License-Identifier: MIT
+
+// Package metrics produces netexp's Prometheus metrics.
+package metrics
+
+import (
+	"bytes"
+	"fmt"
+	"slices"
+	"time"
+
+	"github.com/layer8co/netexp/internal/netdev"
+	"github.com/layer8co/netexp/internal/series"
+)
+
+// e.g. a burst window of 5 seconds and an output window of 60 seconds
+// provides the metric of `the maximum 5 second burst over the last 60 seconds`.
+type Metrics struct {
+	Config
+	recv      *series.TimeSeries
+	trns      *series.TimeSeries
+	recvBurst []*series.TimeSeries
+	trnsBurst []*series.TimeSeries
+	netdev    *netdev.NetDev
+}
+
+type Config struct {
+	Interval      time.Duration
+	BurstWindows  []time.Duration
+	OutputWindows []time.Duration
+}
+
+func New(c Config) *Metrics {
+	m := &Metrics{
+		Config: c,
+	}
+	window := slices.Max(m.OutputWindows)
+	m.recv = series.New(m.Interval, window)
+	m.trns = series.New(m.Interval, window)
+	for range m.BurstWindows {
+		m.recvBurst = append(m.recvBurst, series.New(m.Interval, window))
+		m.trnsBurst = append(m.trnsBurst, series.New(m.Interval, window))
+	}
+	return m
+}
+func (m *Metrics) Step(recv, trns int64, b []byte) []byte {
+	m.recv.Put(recv)
+	m.trns.Put(trns)
+	b = fmt.Appendf(b, "netexp_recv_bytes %d\n", recv)
+	b = fmt.Appendf(b, "netexp_trns_bytes %d\n", trns)
+	for i, bw := range m.BurstWindows {
+		recvBurst, ok := m.recv.Rate(bw)
+		if ok {
+			m.recvBurst[i].Put(recvBurst)
+		}
+		trnsBurst, ok := m.trns.Rate(bw)
+		if ok {
+			m.trnsBurst[i].Put(trnsBurst)
+		}
+		for _, ow := range m.OutputWindows {
+			maxRecvBurst, ok := m.recvBurst[i].Max(ow)
+			if ok {
+				b = fmt.Appendf(
+					b,
+					"netexp_max_%s_recv_burst_bps_over_%s %d\n",
+					bw, ow, maxRecvBurst,
+				)
+			}
+			maxTransBurst, ok := m.trnsBurst[i].Max(ow)
+			if ok {
+				b = fmt.Appendf(
+					b,
+					"netexp_max_%s_trns_burst_bps_over_%s %d\n",
+					bw, ow, maxTransBurst,
+				)
+			}
+		}
+	}
+	b = bytes.TrimRight(b, "\n")
+	return b
+}