github.com/Jeffail/benthos/v3@v3.65.0/lib/metrics/rename.go

package metrics

import (
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"regexp"
	"sort"

	"github.com/Jeffail/benthos/v3/internal/docs"
	"github.com/Jeffail/benthos/v3/lib/log"
)

//------------------------------------------------------------------------------

func init() {
	Constructors[TypeRename] = TypeSpec{
		constructor: NewRename,
		Status:      docs.StatusDeprecated,
		Summary: `
Rename metric paths as they are registered.`,
		FieldSpecs: docs.FieldSpecs{
			docs.FieldCommon("by_regexp", `
A list of objects, each specifying an RE2 regular expression which will be
tested against each metric path registered. Each occurrence of the expression
will be replaced with the specified value. Inside the value $ signs are
interpreted as submatch expansions, e.g. $1 represents the first submatch.

The field `+"`to_label`"+` may contain any number of key/value pairs to be
added to a metric as labels, where the value may contain submatches from the
provided pattern. This allows you to extract (left-most) matched segments of the
renamed path into the label values.`,
				[]interface{}{
					map[string]interface{}{
						"pattern": "foo\\.([a-z]*)\\.([a-z]*)",
						"value":   "foo.$1",
						"to_label": map[string]interface{}{
							"bar": "$2",
						},
					},
				},
			).WithChildren(
				docs.FieldDeprecated("pattern"),
				docs.FieldDeprecated("value"),
				docs.FieldDeprecated("to_label").Map().HasType(docs.FieldTypeString),
			).Array(),
			docs.FieldCommon("child", "A child metric type, this is where renamed metrics will be routed.").HasType(docs.FieldTypeMetrics),
		},
		Description: `
Metrics must be matched using dot notation even if the chosen output uses a
different form. For example, the path would be 'foo.bar' rather than 'foo_bar'
even when sending metrics to Prometheus. A full list of metrics paths that
Benthos registers can be found in [this list](/docs/components/metrics/about#paths).`,
		Footnotes: `
## Examples

In order to replace the paths 'foo.bar.0.zap' and 'foo.baz.1.zap' with 'zip.bar'
and 'zip.baz' respectively, and store the respective values '0' and '1' under
the label key 'index' we could use this config:

` + "```yaml" + `
metrics:
  rename:
    by_regexp:
      - pattern: "foo\\.([a-z]*)\\.([a-z]*)\\.zap"
        value: "zip.$1"
        to_label:
          index: $2
    child:
      statsd:
        prefix: foo
        address: localhost:8125
` + "```" + `

These labels will only be injected into metrics registered without pre-existing
labels. Therefore it's currently not possible to combine labels registered from
the ` + "[`metric` processor](/docs/components/processors/metric)" + ` with labels
set via renaming.

## Debugging

In order to see logs breaking down which metrics are registered and whether they
are renamed enable logging at the TRACE level.`,
	}
}

//------------------------------------------------------------------------------

// RenameByRegexpConfig contains config fields for a rename by regular
// expression pattern.
type RenameByRegexpConfig struct {
	Pattern string            `json:"pattern" yaml:"pattern"`
	Value   string            `json:"value" yaml:"value"`
	Labels  map[string]string `json:"to_label" yaml:"to_label"`
}

// RenameConfig contains config fields for the Rename metric type.
type RenameConfig struct {
	ByRegexp []RenameByRegexpConfig `json:"by_regexp" yaml:"by_regexp"`
	Child    *Config                `json:"child" yaml:"child"`
}

// NewRenameConfig returns a RenameConfig with default values.
func NewRenameConfig() RenameConfig {
	return RenameConfig{
		ByRegexp: []RenameByRegexpConfig{},
		Child:    nil,
	}
}

//------------------------------------------------------------------------------

type dummyRenameConfig struct {
	ByRegexp []RenameByRegexpConfig `json:"by_regexp" yaml:"by_regexp"`
	Child    interface{}            `json:"child" yaml:"child"`
}

// MarshalJSON prints an empty object instead of nil.
func (w RenameConfig) MarshalJSON() ([]byte, error) {
	dummy := dummyRenameConfig{
		ByRegexp: w.ByRegexp,
		Child:    w.Child,
	}
	if w.Child == nil {
		dummy.Child = struct{}{}
	}
	return json.Marshal(dummy)
}

// MarshalYAML prints an empty object instead of nil.
func (w RenameConfig) MarshalYAML() (interface{}, error) {
	dummy := dummyRenameConfig{
		ByRegexp: w.ByRegexp,
		Child:    w.Child,
	}
	if w.Child == nil {
		dummy.Child = struct{}{}
	}
	return dummy, nil
}

//------------------------------------------------------------------------------

type renameByRegexp struct {
	expression *regexp.Regexp
	value      string
	labels     map[string]string
}

// Rename is a statistics object that wraps a separate statistics object
// and only permits statistics that pass through the whitelist to be recorded.
type Rename struct {
	byRegexp []renameByRegexp
	s        Type
	log      log.Modular
}

// NewRename creates and returns a new Rename object
func NewRename(config Config, opts ...func(Type)) (Type, error) {
	if config.Rename.Child == nil {
		return nil, errors.New("cannot create a rename metric without a child")
	}

	child, err := New(*config.Rename.Child)
	if err != nil {
		return nil, err
	}

	r := &Rename{
		s:   child,
		log: log.Noop(),
	}

	for _, opt := range opts {
		opt(r)
	}

	for _, p := range config.Rename.ByRegexp {
		re, err := regexp.Compile(p.Pattern)
		if err != nil {
			return nil, fmt.Errorf("invalid regular expression: '%s': %v", p, err)
		}
		r.byRegexp = append(r.byRegexp, renameByRegexp{
			expression: re,
			value:      p.Value,
			labels:     p.Labels,
		})
	}

	return r, nil
}

//------------------------------------------------------------------------------

// renamePath checks whether or not a given path is in the allowed set of
// paths for the Rename metrics stat.
func (r *Rename) renamePath(path string) (outPath string, labels map[string]string) {
	renamed := false
	labels = make(map[string]string)
	for _, rr := range r.byRegexp {
		newPath := rr.expression.ReplaceAllString(path, rr.value)
		if newPath != path {
			renamed = true
			r.log.Tracef("Renamed metric path '%v' to '%v' as per regexp '%v'\n", path, newPath, rr.expression.String())
		}
		if rr.labels != nil && len(rr.labels) > 0 {
			// Extract only the matching segment of the path (left-most)
			leftPath := rr.expression.FindString(path)
			if len(leftPath) > 0 {
				for k, v := range rr.labels {
					v = rr.expression.ReplaceAllString(leftPath, v)
					labels[k] = v
					r.log.Tracef("Renamed label '%v' to '%v' as per regexp '%v'\n", k, v, rr.expression.String())
				}
			}
		}
		path = newPath
	}
	if !renamed {
		r.log.Tracef("Registered metric path '%v' unchanged\n", path)
	}
	return path, labels
}

//------------------------------------------------------------------------------

func labelsFromMap(labels map[string]string) (names, values []string) {
	names = make([]string, 0, len(labels))
	for k := range labels {
		names = append(names, k)
	}
	sort.Strings(names)
	values = make([]string, 0, len(names))
	for _, k := range names {
		values = append(values, labels[k])
	}
	return names, values
}

// GetCounter returns a stat counter object for a path.
func (r *Rename) GetCounter(path string) StatCounter {
	rpath, labels := r.renamePath(path)
	if len(labels) == 0 {
		return r.s.GetCounter(rpath)
	}
	names, values := labelsFromMap(labels)
	return r.s.GetCounterVec(rpath, names).With(values...)
}

// GetCounterVec returns a stat counter object for a path with the labels
// and values.
func (r *Rename) GetCounterVec(path string, n []string) StatCounterVec {
	rpath, _ := r.renamePath(path)
	return r.s.GetCounterVec(rpath, n)
}

// GetTimer returns a stat timer object for a path.
func (r *Rename) GetTimer(path string) StatTimer {
	rpath, labels := r.renamePath(path)
	if len(labels) == 0 {
		return r.s.GetTimer(rpath)
	}

	names, values := labelsFromMap(labels)
	return r.s.GetTimerVec(rpath, names).With(values...)
}

// GetTimerVec returns a stat timer object for a path with the labels
// and values.
func (r *Rename) GetTimerVec(path string, n []string) StatTimerVec {
	rpath, _ := r.renamePath(path)
	return r.s.GetTimerVec(rpath, n)
}

// GetGauge returns a stat gauge object for a path.
func (r *Rename) GetGauge(path string) StatGauge {
	rpath, labels := r.renamePath(path)
	if len(labels) == 0 {
		return r.s.GetGauge(rpath)
	}

	names, values := labelsFromMap(labels)
	return r.s.GetGaugeVec(rpath, names).With(values...)
}

// GetGaugeVec returns a stat timer object for a path with the labels
// discarded.
func (r *Rename) GetGaugeVec(path string, n []string) StatGaugeVec {
	rpath, _ := r.renamePath(path)
	return r.s.GetGaugeVec(rpath, n)
}

// SetLogger sets the logger used to print connection errors.
func (r *Rename) SetLogger(log log.Modular) {
	r.log = log.NewModule(".rename")
	r.s.SetLogger(log)
}

// Close stops the Statsd object from aggregating metrics and cleans up
// resources.
func (r *Rename) Close() error {
	return r.s.Close()
}

//------------------------------------------------------------------------------

// HandlerFunc returns an http.HandlerFunc for accessing metrics for appropriate
// child types
func (r *Rename) HandlerFunc() http.HandlerFunc {
	if wHandlerFunc, ok := r.s.(WithHandlerFunc); ok {
		return wHandlerFunc.HandlerFunc()
	}

	return func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(501)
		w.Write([]byte("The child of this rename does not support HTTP metrics."))
	}
}

//------------------------------------------------------------------------------