Adding upstream version 1.34.4.

Signed-off-by: Daniel Baumann <daniel@debian.org>

plugins/inputs/aurora/aurora.go

@@ -0,0 +1,258 @@
+//go:generate ../../../tools/readme_config_includer/generator
+package aurora
+
+import (
+	"context"
+	_ "embed"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/config"
+	"github.com/influxdata/telegraf/plugins/common/tls"
+	"github.com/influxdata/telegraf/plugins/inputs"
+)
+
+//go:embed sample.conf
+var sampleConfig string
+
+type roleType int
+
+const (
+	unknown roleType = iota
+	leader
+	follower
+)
+
+func (r roleType) String() string {
+	switch r {
+	case leader:
+		return "leader"
+	case follower:
+		return "follower"
+	default:
+		return "unknown"
+	}
+}
+
+var (
+	defaultTimeout = 5 * time.Second
+	defaultRoles   = []string{"leader", "follower"}
+)
+
+type vars map[string]interface{}
+
+type Aurora struct {
+	Schedulers []string        `toml:"schedulers"`
+	Roles      []string        `toml:"roles"`
+	Timeout    config.Duration `toml:"timeout"`
+	Username   string          `toml:"username"`
+	Password   string          `toml:"password"`
+	tls.ClientConfig
+
+	client *http.Client
+	urls   []*url.URL
+}
+
+func (*Aurora) SampleConfig() string {
+	return sampleConfig
+}
+
+func (a *Aurora) Gather(acc telegraf.Accumulator) error {
+	if a.client == nil {
+		err := a.initialize()
+		if err != nil {
+			return err
+		}
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(a.Timeout))
+	defer cancel()
+
+	var wg sync.WaitGroup
+	for _, u := range a.urls {
+		wg.Add(1)
+		go func(u *url.URL) {
+			defer wg.Done()
+			role, err := a.gatherRole(ctx, u)
+			if err != nil {
+				acc.AddError(fmt.Errorf("%s: %w", u, err))
+				return
+			}
+
+			if !a.roleEnabled(role) {
+				return
+			}
+
+			err = a.gatherScheduler(ctx, u, role, acc)
+			if err != nil {
+				acc.AddError(fmt.Errorf("%s: %w", u, err))
+			}
+		}(u)
+	}
+	wg.Wait()
+
+	return nil
+}
+
+func (a *Aurora) initialize() error {
+	tlsCfg, err := a.ClientConfig.TLSConfig()
+	if err != nil {
+		return err
+	}
+
+	client := &http.Client{
+		Transport: &http.Transport{
+			Proxy:           http.ProxyFromEnvironment,
+			TLSClientConfig: tlsCfg,
+		},
+	}
+
+	urls := make([]*url.URL, 0, len(a.Schedulers))
+	for _, s := range a.Schedulers {
+		loc, err := url.Parse(s)
+		if err != nil {
+			return err
+		}
+
+		urls = append(urls, loc)
+	}
+
+	if a.Timeout < config.Duration(time.Second) {
+		a.Timeout = config.Duration(defaultTimeout)
+	}
+
+	if len(a.Roles) == 0 {
+		a.Roles = defaultRoles
+	}
+
+	a.client = client
+	a.urls = urls
+	return nil
+}
+
+func (a *Aurora) roleEnabled(role roleType) bool {
+	if len(a.Roles) == 0 {
+		return true
+	}
+
+	for _, v := range a.Roles {
+		if role.String() == v {
+			return true
+		}
+	}
+	return false
+}
+
+func (a *Aurora) gatherRole(ctx context.Context, origin *url.URL) (roleType, error) {
+	loc := *origin
+	loc.Path = "leaderhealth"
+	req, err := http.NewRequest("GET", loc.String(), nil)
+	if err != nil {
+		return unknown, err
+	}
+
+	if a.Username != "" || a.Password != "" {
+		req.SetBasicAuth(a.Username, a.Password)
+	}
+	req.Header.Add("Accept", "text/plain")
+
+	resp, err := a.client.Do(req.WithContext(ctx))
+	if err != nil {
+		return unknown, err
+	}
+	if err := resp.Body.Close(); err != nil {
+		return unknown, fmt.Errorf("closing body failed: %w", err)
+	}
+
+	switch resp.StatusCode {
+	case http.StatusOK:
+		return leader, nil
+	case http.StatusBadGateway:
+		fallthrough
+	case http.StatusServiceUnavailable:
+		return follower, nil
+	default:
+		return unknown, fmt.Errorf("%v", resp.Status)
+	}
+}
+
+func (a *Aurora) gatherScheduler(
+	ctx context.Context, origin *url.URL, role roleType, acc telegraf.Accumulator,
+) error {
+	loc := *origin
+	loc.Path = "vars.json"
+	req, err := http.NewRequest("GET", loc.String(), nil)
+	if err != nil {
+		return err
+	}
+
+	if a.Username != "" || a.Password != "" {
+		req.SetBasicAuth(a.Username, a.Password)
+	}
+	req.Header.Add("Accept", "application/json")
+
+	resp, err := a.client.Do(req.WithContext(ctx))
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("%v", resp.Status)
+	}
+
+	var metrics vars
+	decoder := json.NewDecoder(resp.Body)
+	decoder.UseNumber()
+	err = decoder.Decode(&metrics)
+	if err != nil {
+		return fmt.Errorf("decoding response: %w", err)
+	}
+
+	var fields = make(map[string]interface{}, len(metrics))
+	for k, v := range metrics {
+		switch v := v.(type) {
+		case json.Number:
+			// Aurora encodes numbers as you would specify them as a literal,
+			// use this to determine if a value is a float or int.
+			if strings.ContainsAny(v.String(), ".eE") {
+				fv, err := v.Float64()
+				if err != nil {
+					acc.AddError(err)
+					continue
+				}
+				fields[k] = fv
+			} else {
+				fi, err := v.Int64()
+				if err != nil {
+					acc.AddError(err)
+					continue
+				}
+				fields[k] = fi
+			}
+		default:
+			continue
+		}
+	}
+
+	acc.AddFields("aurora",
+		fields,
+		map[string]string{
+			"scheduler": origin.String(),
+			"role":      role.String(),
+		},
+	)
+	return nil
+}
+
+func init() {
+	inputs.Add("aurora", func() telegraf.Input {
+		return &Aurora{}
+	})
+}

plugins/inputs/aurora/aurora_test.go

@@ -0,0 +1,278 @@
+package aurora
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/influxdata/telegraf/testutil"
+)
+
+type (
+	testHandlerFunc func(t *testing.T, w http.ResponseWriter, r *http.Request)
+	checkFunc       func(t *testing.T, err error, acc *testutil.Accumulator)
+)
+
+func TestAurora(t *testing.T) {
+	ts := httptest.NewServer(http.NotFoundHandler())
+	defer ts.Close()
+
+	u, err := url.Parse("http://" + ts.Listener.Addr().String())
+	require.NoError(t, err)
+
+	tests := []struct {
+		name         string
+		plugin       *Aurora
+		schedulers   []string
+		roles        []string
+		leaderhealth testHandlerFunc
+		varsjson     testHandlerFunc
+		check        checkFunc
+	}{
+		{
+			name: "minimal",
+			leaderhealth: func(_ *testing.T, w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			},
+			varsjson: func(t *testing.T, w http.ResponseWriter, _ *http.Request) {
+				body := `{
+					"variable_scrape_events": 2958,
+					"variable_scrape_events_per_sec": 1.0,
+					"variable_scrape_micros_per_event": 1484.0,
+					"variable_scrape_micros_total": 4401084,
+					"variable_scrape_micros_total_per_sec": 1485.0
+				}`
+				w.WriteHeader(http.StatusOK)
+				_, err := w.Write([]byte(body))
+				require.NoError(t, err)
+			},
+			check: func(t *testing.T, err error, acc *testutil.Accumulator) {
+				require.NoError(t, err)
+				require.Len(t, acc.Metrics, 1)
+				acc.AssertContainsTaggedFields(t,
+					"aurora",
+					map[string]interface{}{
+						"variable_scrape_events":               int64(2958),
+						"variable_scrape_events_per_sec":       1.0,
+						"variable_scrape_micros_per_event":     1484.0,
+						"variable_scrape_micros_total":         int64(4401084),
+						"variable_scrape_micros_total_per_sec": 1485.0,
+					},
+					map[string]string{
+						"scheduler": u.String(),
+						"role":      "leader",
+					},
+				)
+			},
+		},
+		{
+			name:  "disabled role",
+			roles: []string{"leader"},
+			leaderhealth: func(_ *testing.T, w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusServiceUnavailable)
+			},
+			check: func(t *testing.T, err error, acc *testutil.Accumulator) {
+				require.NoError(t, err)
+				require.NoError(t, acc.FirstError())
+				require.Empty(t, acc.Metrics)
+			},
+		},
+		{
+			name: "no metrics available",
+			leaderhealth: func(_ *testing.T, w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			},
+			varsjson: func(t *testing.T, w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				_, err := w.Write([]byte("{}"))
+				require.NoError(t, err)
+			},
+			check: func(t *testing.T, err error, acc *testutil.Accumulator) {
+				require.NoError(t, err)
+				require.NoError(t, acc.FirstError())
+				require.Empty(t, acc.Metrics)
+			},
+		},
+		{
+			name: "string metrics skipped",
+			leaderhealth: func(_ *testing.T, w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			},
+			varsjson: func(t *testing.T, w http.ResponseWriter, _ *http.Request) {
+				body := `{
+					"foo": "bar"
+				}`
+				w.WriteHeader(http.StatusOK)
+				_, err := w.Write([]byte(body))
+				require.NoError(t, err)
+			},
+			check: func(t *testing.T, err error, acc *testutil.Accumulator) {
+				require.NoError(t, err)
+				require.NoError(t, acc.FirstError())
+				require.Empty(t, acc.Metrics)
+			},
+		},
+		{
+			name: "float64 unparsable",
+			leaderhealth: func(_ *testing.T, w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			},
+			varsjson: func(t *testing.T, w http.ResponseWriter, _ *http.Request) {
+				// too large
+				body := `{
+					"foo": 1e309
+				}`
+				w.WriteHeader(http.StatusOK)
+				_, err := w.Write([]byte(body))
+				require.NoError(t, err)
+			},
+			check: func(t *testing.T, err error, acc *testutil.Accumulator) {
+				require.NoError(t, err)
+				require.Error(t, acc.FirstError())
+				require.Empty(t, acc.Metrics)
+			},
+		},
+		{
+			name: "int64 unparsable",
+			leaderhealth: func(_ *testing.T, w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			},
+			varsjson: func(t *testing.T, w http.ResponseWriter, _ *http.Request) {
+				// too large
+				body := `{
+					"foo": 9223372036854775808
+				}`
+				w.WriteHeader(http.StatusOK)
+				_, err := w.Write([]byte(body))
+				require.NoError(t, err)
+			},
+			check: func(t *testing.T, err error, acc *testutil.Accumulator) {
+				require.NoError(t, err)
+				require.Error(t, acc.FirstError())
+				require.Empty(t, acc.Metrics)
+			},
+		},
+		{
+			name: "bad json",
+			leaderhealth: func(_ *testing.T, w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			},
+			varsjson: func(t *testing.T, w http.ResponseWriter, _ *http.Request) {
+				body := `{]`
+				w.WriteHeader(http.StatusOK)
+				_, err := w.Write([]byte(body))
+				require.NoError(t, err)
+			},
+			check: func(t *testing.T, err error, acc *testutil.Accumulator) {
+				require.NoError(t, err)
+				require.Error(t, acc.FirstError())
+				require.Empty(t, acc.Metrics)
+			},
+		},
+		{
+			name: "wrong status code",
+			leaderhealth: func(_ *testing.T, w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			},
+			varsjson: func(t *testing.T, w http.ResponseWriter, _ *http.Request) {
+				body := `{
+					"value": 42
+				}`
+				w.WriteHeader(http.StatusServiceUnavailable)
+				_, err := w.Write([]byte(body))
+				require.NoError(t, err)
+			},
+			check: func(t *testing.T, err error, acc *testutil.Accumulator) {
+				require.NoError(t, err)
+				require.Error(t, acc.FirstError())
+				require.Empty(t, acc.Metrics)
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ts.Config.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				switch r.URL.Path {
+				case "/leaderhealth":
+					tt.leaderhealth(t, w, r)
+				case "/vars.json":
+					tt.varsjson(t, w, r)
+				default:
+					w.WriteHeader(http.StatusNotFound)
+				}
+			})
+
+			var acc testutil.Accumulator
+			plugin := &Aurora{}
+			plugin.Schedulers = []string{u.String()}
+			plugin.Roles = tt.roles
+			err := plugin.Gather(&acc)
+			tt.check(t, err, &acc)
+		})
+	}
+}
+
+func TestBasicAuth(t *testing.T) {
+	ts := httptest.NewServer(http.NotFoundHandler())
+	defer ts.Close()
+
+	u, err := url.Parse("http://" + ts.Listener.Addr().String())
+	require.NoError(t, err)
+
+	tests := []struct {
+		name     string
+		username string
+		password string
+	}{
+		{
+			name: "no auth",
+		},
+		{
+			name:     "basic auth",
+			username: "username",
+			password: "pa$$word",
+		},
+		{
+			name:     "username only",
+			username: "username",
+		},
+		{
+			name:     "password only",
+			password: "pa$$word",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ts.Config.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				username, password, _ := r.BasicAuth()
+				if username != tt.username {
+					w.WriteHeader(http.StatusInternalServerError)
+					t.Errorf("Not equal, expected: %q, actual: %q", tt.username, username)
+					return
+				}
+				if password != tt.password {
+					w.WriteHeader(http.StatusInternalServerError)
+					t.Errorf("Not equal, expected: %q, actual: %q", tt.password, password)
+					return
+				}
+				w.WriteHeader(http.StatusOK)
+				if _, err := w.Write([]byte("{}")); err != nil {
+					w.WriteHeader(http.StatusInternalServerError)
+					t.Error(err)
+					return
+				}
+			})
+
+			var acc testutil.Accumulator
+			plugin := &Aurora{}
+			plugin.Schedulers = []string{u.String()}
+			plugin.Username = tt.username
+			plugin.Password = tt.password
+			err := plugin.Gather(&acc)
+			require.NoError(t, err)
+		})
+	}
+}

plugins/inputs/aurora/sample.conf

@@ -0,0 +1,24 @@
+# Gather metrics from Apache Aurora schedulers
+[[inputs.aurora]]
+  ## Schedulers are the base addresses of your Aurora Schedulers
+  schedulers = ["http://127.0.0.1:8081"]
+
+  ## Set of role types to collect metrics from.
+  ##
+  ## The scheduler roles are checked each interval by contacting the
+  ## scheduler nodes; zookeeper is not contacted.
+  # roles = ["leader", "follower"]
+
+  ## Timeout is the max time for total network operations.
+  # timeout = "5s"
+
+  ## Username and password are sent using HTTP Basic Auth.
+  # username = "username"
+  # password = "pa$$word"
+
+  ## Optional TLS Config
+  # tls_ca = "/etc/telegraf/ca.pem"
+  # tls_cert = "/etc/telegraf/cert.pem"
+  # tls_key = "/etc/telegraf/key.pem"
+  ## Use TLS but skip chain & host verification
+  # insecure_skip_verify = false