mirror of
https://github.com/prometheus/prometheus.git
synced 2024-11-13 17:14:05 -08:00
8fdfa8abea
i) Uses the more idiomatic Wrap and Wrapf methods for creating nested errors. ii) Fixes some incorrect usages of fmt.Errorf where the error messages don't have any formatting directives. iii) Does away with the use of fmt package for errors in favour of pkg/errors Signed-off-by: tariqibrahim <tariq181290@gmail.com>
268 lines
7.7 KiB
Go
268 lines
7.7 KiB
Go
// Copyright 2015 The Prometheus Authors
|
|
// 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 relabel
|
|
|
|
import (
|
|
"crypto/md5"
|
|
"fmt"
|
|
"regexp"
|
|
"strings"
|
|
|
|
"github.com/pkg/errors"
|
|
"github.com/prometheus/common/model"
|
|
|
|
"github.com/prometheus/prometheus/pkg/labels"
|
|
)
|
|
|
|
var (
|
|
relabelTarget = regexp.MustCompile(`^(?:(?:[a-zA-Z_]|\$(?:\{\w+\}|\w+))+\w*)+$`)
|
|
|
|
DefaultRelabelConfig = Config{
|
|
Action: Replace,
|
|
Separator: ";",
|
|
Regex: MustNewRegexp("(.*)"),
|
|
Replacement: "$1",
|
|
}
|
|
)
|
|
|
|
// Action is the action to be performed on relabeling.
|
|
type Action string
|
|
|
|
const (
|
|
// Replace performs a regex replacement.
|
|
Replace Action = "replace"
|
|
// Keep drops targets for which the input does not match the regex.
|
|
Keep Action = "keep"
|
|
// Drop drops targets for which the input does match the regex.
|
|
Drop Action = "drop"
|
|
// HashMod sets a label to the modulus of a hash of labels.
|
|
HashMod Action = "hashmod"
|
|
// LabelMap copies labels to other labelnames based on a regex.
|
|
LabelMap Action = "labelmap"
|
|
// LabelDrop drops any label matching the regex.
|
|
LabelDrop Action = "labeldrop"
|
|
// LabelKeep drops any label not matching the regex.
|
|
LabelKeep Action = "labelkeep"
|
|
)
|
|
|
|
// UnmarshalYAML implements the yaml.Unmarshaler interface.
|
|
func (a *Action) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
|
var s string
|
|
if err := unmarshal(&s); err != nil {
|
|
return err
|
|
}
|
|
switch act := Action(strings.ToLower(s)); act {
|
|
case Replace, Keep, Drop, HashMod, LabelMap, LabelDrop, LabelKeep:
|
|
*a = act
|
|
return nil
|
|
}
|
|
return errors.Errorf("unknown relabel action %q", s)
|
|
}
|
|
|
|
// Config is the configuration for relabeling of target label sets.
|
|
type Config struct {
|
|
// A list of labels from which values are taken and concatenated
|
|
// with the configured separator in order.
|
|
SourceLabels model.LabelNames `yaml:"source_labels,flow,omitempty"`
|
|
// Separator is the string between concatenated values from the source labels.
|
|
Separator string `yaml:"separator,omitempty"`
|
|
// Regex against which the concatenation is matched.
|
|
Regex Regexp `yaml:"regex,omitempty"`
|
|
// Modulus to take of the hash of concatenated values from the source labels.
|
|
Modulus uint64 `yaml:"modulus,omitempty"`
|
|
// TargetLabel is the label to which the resulting string is written in a replacement.
|
|
// Regexp interpolation is allowed for the replace action.
|
|
TargetLabel string `yaml:"target_label,omitempty"`
|
|
// Replacement is the regex replacement pattern to be used.
|
|
Replacement string `yaml:"replacement,omitempty"`
|
|
// Action is the action to be performed for the relabeling.
|
|
Action Action `yaml:"action,omitempty"`
|
|
}
|
|
|
|
// UnmarshalYAML implements the yaml.Unmarshaler interface.
|
|
func (c *Config) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
|
*c = DefaultRelabelConfig
|
|
type plain Config
|
|
if err := unmarshal((*plain)(c)); err != nil {
|
|
return err
|
|
}
|
|
if c.Regex.Regexp == nil {
|
|
c.Regex = MustNewRegexp("")
|
|
}
|
|
if c.Modulus == 0 && c.Action == HashMod {
|
|
return errors.Errorf("relabel configuration for hashmod requires non-zero modulus")
|
|
}
|
|
if (c.Action == Replace || c.Action == HashMod) && c.TargetLabel == "" {
|
|
return errors.Errorf("relabel configuration for %s action requires 'target_label' value", c.Action)
|
|
}
|
|
if c.Action == Replace && !relabelTarget.MatchString(c.TargetLabel) {
|
|
return errors.Errorf("%q is invalid 'target_label' for %s action", c.TargetLabel, c.Action)
|
|
}
|
|
if c.Action == LabelMap && !relabelTarget.MatchString(c.Replacement) {
|
|
return errors.Errorf("%q is invalid 'replacement' for %s action", c.Replacement, c.Action)
|
|
}
|
|
if c.Action == HashMod && !model.LabelName(c.TargetLabel).IsValid() {
|
|
return errors.Errorf("%q is invalid 'target_label' for %s action", c.TargetLabel, c.Action)
|
|
}
|
|
|
|
if c.Action == LabelDrop || c.Action == LabelKeep {
|
|
if c.SourceLabels != nil ||
|
|
c.TargetLabel != DefaultRelabelConfig.TargetLabel ||
|
|
c.Modulus != DefaultRelabelConfig.Modulus ||
|
|
c.Separator != DefaultRelabelConfig.Separator ||
|
|
c.Replacement != DefaultRelabelConfig.Replacement {
|
|
return errors.Errorf("%s action requires only 'regex', and no other fields", c.Action)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Regexp encapsulates a regexp.Regexp and makes it YAML marshalable.
|
|
type Regexp struct {
|
|
*regexp.Regexp
|
|
original string
|
|
}
|
|
|
|
// NewRegexp creates a new anchored Regexp and returns an error if the
|
|
// passed-in regular expression does not compile.
|
|
func NewRegexp(s string) (Regexp, error) {
|
|
regex, err := regexp.Compile("^(?:" + s + ")$")
|
|
return Regexp{
|
|
Regexp: regex,
|
|
original: s,
|
|
}, err
|
|
}
|
|
|
|
// MustNewRegexp works like NewRegexp, but panics if the regular expression does not compile.
|
|
func MustNewRegexp(s string) Regexp {
|
|
re, err := NewRegexp(s)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return re
|
|
}
|
|
|
|
// UnmarshalYAML implements the yaml.Unmarshaler interface.
|
|
func (re *Regexp) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
|
var s string
|
|
if err := unmarshal(&s); err != nil {
|
|
return err
|
|
}
|
|
r, err := NewRegexp(s)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*re = r
|
|
return nil
|
|
}
|
|
|
|
// MarshalYAML implements the yaml.Marshaler interface.
|
|
func (re Regexp) MarshalYAML() (interface{}, error) {
|
|
if re.original != "" {
|
|
return re.original, nil
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
// Process returns a relabeled copy of the given label set. The relabel configurations
|
|
// are applied in order of input.
|
|
// If a label set is dropped, nil is returned.
|
|
// May return the input labelSet modified.
|
|
func Process(labels labels.Labels, cfgs ...*Config) labels.Labels {
|
|
for _, cfg := range cfgs {
|
|
labels = relabel(labels, cfg)
|
|
if labels == nil {
|
|
return nil
|
|
}
|
|
}
|
|
return labels
|
|
}
|
|
|
|
func relabel(lset labels.Labels, cfg *Config) labels.Labels {
|
|
values := make([]string, 0, len(cfg.SourceLabels))
|
|
for _, ln := range cfg.SourceLabels {
|
|
values = append(values, lset.Get(string(ln)))
|
|
}
|
|
val := strings.Join(values, cfg.Separator)
|
|
|
|
lb := labels.NewBuilder(lset)
|
|
|
|
switch cfg.Action {
|
|
case Drop:
|
|
if cfg.Regex.MatchString(val) {
|
|
return nil
|
|
}
|
|
case Keep:
|
|
if !cfg.Regex.MatchString(val) {
|
|
return nil
|
|
}
|
|
case Replace:
|
|
indexes := cfg.Regex.FindStringSubmatchIndex(val)
|
|
// If there is no match no replacement must take place.
|
|
if indexes == nil {
|
|
break
|
|
}
|
|
target := model.LabelName(cfg.Regex.ExpandString([]byte{}, cfg.TargetLabel, val, indexes))
|
|
if !target.IsValid() {
|
|
lb.Del(cfg.TargetLabel)
|
|
break
|
|
}
|
|
res := cfg.Regex.ExpandString([]byte{}, cfg.Replacement, val, indexes)
|
|
if len(res) == 0 {
|
|
lb.Del(cfg.TargetLabel)
|
|
break
|
|
}
|
|
lb.Set(string(target), string(res))
|
|
case HashMod:
|
|
mod := sum64(md5.Sum([]byte(val))) % cfg.Modulus
|
|
lb.Set(cfg.TargetLabel, fmt.Sprintf("%d", mod))
|
|
case LabelMap:
|
|
for _, l := range lset {
|
|
if cfg.Regex.MatchString(l.Name) {
|
|
res := cfg.Regex.ReplaceAllString(l.Name, cfg.Replacement)
|
|
lb.Set(res, l.Value)
|
|
}
|
|
}
|
|
case LabelDrop:
|
|
for _, l := range lset {
|
|
if cfg.Regex.MatchString(l.Name) {
|
|
lb.Del(l.Name)
|
|
}
|
|
}
|
|
case LabelKeep:
|
|
for _, l := range lset {
|
|
if !cfg.Regex.MatchString(l.Name) {
|
|
lb.Del(l.Name)
|
|
}
|
|
}
|
|
default:
|
|
panic(errors.Errorf("relabel: unknown relabel action type %q", cfg.Action))
|
|
}
|
|
|
|
return lb.Labels()
|
|
}
|
|
|
|
// sum64 sums the md5 hash to an uint64.
|
|
func sum64(hash [md5.Size]byte) uint64 {
|
|
var s uint64
|
|
|
|
for i, b := range hash {
|
|
shift := uint64((md5.Size - i - 1) * 8)
|
|
|
|
s |= uint64(b) << shift
|
|
}
|
|
return s
|
|
}
|