141 lines
3.3 KiB
Go
141 lines
3.3 KiB
Go
package enum
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
|
|
"github.com/influxdata/telegraf"
|
|
"github.com/influxdata/telegraf/plugins/processors"
|
|
)
|
|
|
|
var sampleConfig = `
|
|
[[processors.enum.mapping]]
|
|
## Name of the field to map
|
|
field = "status"
|
|
|
|
## Name of the tag to map
|
|
# tag = "status"
|
|
|
|
## Destination tag or field to be used for the mapped value. By default the
|
|
## source tag or field is used, overwriting the original value.
|
|
dest = "status_code"
|
|
|
|
## Default value to be used for all values not contained in the mapping
|
|
## table. When unset, the unmodified value for the field will be used if no
|
|
## match is found.
|
|
# default = 0
|
|
|
|
## Table of mappings
|
|
[processors.enum.mapping.value_mappings]
|
|
green = 1
|
|
amber = 2
|
|
red = 3
|
|
`
|
|
|
|
type EnumMapper struct {
|
|
Mappings []Mapping `toml:"mapping"`
|
|
}
|
|
|
|
type Mapping struct {
|
|
Tag string
|
|
Field string
|
|
Dest string
|
|
Default interface{}
|
|
ValueMappings map[string]interface{}
|
|
}
|
|
|
|
func (mapper *EnumMapper) SampleConfig() string {
|
|
return sampleConfig
|
|
}
|
|
|
|
func (mapper *EnumMapper) Description() string {
|
|
return "Map enum values according to given table."
|
|
}
|
|
|
|
func (mapper *EnumMapper) Apply(in ...telegraf.Metric) []telegraf.Metric {
|
|
for i := 0; i < len(in); i++ {
|
|
in[i] = mapper.applyMappings(in[i])
|
|
}
|
|
return in
|
|
}
|
|
|
|
func (mapper *EnumMapper) applyMappings(metric telegraf.Metric) telegraf.Metric {
|
|
for _, mapping := range mapper.Mappings {
|
|
if mapping.Field != "" {
|
|
if originalValue, isPresent := metric.GetField(mapping.Field); isPresent {
|
|
if adjustedValue, isString := adjustValue(originalValue).(string); isString {
|
|
if mappedValue, isMappedValuePresent := mapping.mapValue(adjustedValue); isMappedValuePresent {
|
|
writeField(metric, mapping.getDestination(), mappedValue)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if mapping.Tag != "" {
|
|
if originalValue, isPresent := metric.GetTag(mapping.Tag); isPresent {
|
|
if mappedValue, isMappedValuePresent := mapping.mapValue(originalValue); isMappedValuePresent {
|
|
switch val := mappedValue.(type) {
|
|
case string:
|
|
writeTag(metric, mapping.getDestinationTag(), val)
|
|
default:
|
|
writeTag(metric, mapping.getDestinationTag(), fmt.Sprintf("%v", val))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return metric
|
|
}
|
|
|
|
func adjustValue(in interface{}) interface{} {
|
|
switch val := in.(type) {
|
|
case bool:
|
|
return strconv.FormatBool(val)
|
|
case int64:
|
|
return strconv.FormatInt(val, 10)
|
|
case uint64:
|
|
return strconv.FormatUint(val, 10)
|
|
default:
|
|
return in
|
|
}
|
|
}
|
|
|
|
func (mapping *Mapping) mapValue(original string) (interface{}, bool) {
|
|
if mapped, found := mapping.ValueMappings[original]; found == true {
|
|
return mapped, true
|
|
}
|
|
if mapping.Default != nil {
|
|
return mapping.Default, true
|
|
}
|
|
return original, false
|
|
}
|
|
|
|
func (mapping *Mapping) getDestination() string {
|
|
if mapping.Dest != "" {
|
|
return mapping.Dest
|
|
}
|
|
return mapping.Field
|
|
}
|
|
|
|
func (mapping *Mapping) getDestinationTag() string {
|
|
if mapping.Dest != "" {
|
|
return mapping.Dest
|
|
}
|
|
return mapping.Tag
|
|
}
|
|
|
|
func writeField(metric telegraf.Metric, name string, value interface{}) {
|
|
metric.RemoveField(name)
|
|
metric.AddField(name, value)
|
|
}
|
|
|
|
func writeTag(metric telegraf.Metric, name string, value string) {
|
|
metric.RemoveTag(name)
|
|
metric.AddTag(name, value)
|
|
}
|
|
|
|
func init() {
|
|
processors.Add("enum", func() telegraf.Processor {
|
|
return &EnumMapper{}
|
|
})
|
|
}
|