Filter on all container names, use proper name

Resolves #4376

CHANGELOG.md

@@ -6,6 +6,10 @@
 
 - [tengine](./plugins/inputs/tengine/README.md) - Contributed by @ertaoxu
 
+### New Processors
+
+- [enum](./plugins/processors/enum/README.md) - Contributed by @KarstenSchnitter
+
 ### New Aggregators
 
 - [valuecounter](./plugins/aggregators/valuecounter/README.md) - Contributed by @piotr1212
@@ -26,8 +30,11 @@
 - [#4267](https://github.com/influxdata/telegraf/pull/4267): Add option to use of counter time in win perf counters.
 - [#4343](https://github.com/influxdata/telegraf/pull/4343): Add energy and power field and device id tag to fibaro input.
 - [#4347](https://github.com/influxdata/telegraf/pull/4347): Add http path configuration for OpenTSDB output.
+- [#4352](https://github.com/influxdata/telegraf/pull/4352): Gather IPMI metrics concurrently.
+- [#4362](https://github.com/influxdata/telegraf/pull/4362): Add mongo document and connection metrics.
+- [#3772](https://github.com/influxdata/telegraf/pull/3772): Add Enum Processor.
 
-## v1.7.1 [unreleased]
+## v1.7.1 [2018-07-03]
 
 ### Bugfixes
 
@@ -38,6 +45,7 @@
 - [#2910](https://github.com/influxdata/telegraf/issues/2910): Handle mysql input variations in the user_statistics collecting.
 - [#4293](https://github.com/influxdata/telegraf/issues/4293): Fix minmax and basicstats aggregators to use uint64.
 - [#4290](https://github.com/influxdata/telegraf/issues/4290): Document swap input plugin.
+- [#4316](https://github.com/influxdata/telegraf/issues/4316): Fix incorrect precision being applied to metric in http_listener.
 
 ## v1.7 [2018-06-12]
 

plugins/inputs/docker/docker.go

@@ -366,9 +366,22 @@ func (d *Docker) gatherContainer(
 	var v *types.StatsJSON
 	// Parse container name
 	cname := "unknown"
-	if len(container.Names) > 0 {
-		// Not sure what to do with other names, just take the first.
-		cname = strings.TrimPrefix(container.Names[0], "/")
+	match := false
+	if len(container.Names) == 0 { // for tests
+		match = true
+	}
+
+	for i := range container.Names {
+		if !match {
+			match = d.containerFilter.Match(strings.TrimPrefix(container.Names[i], "/"))
+			if match {
+				cname = strings.TrimPrefix(container.Names[i], "/")
+			}
+		}
+	}
+
+	if !match {
+		return nil
 	}
 
 	// the image name sometimes has a version part, or a private repo
@@ -391,10 +404,6 @@ func (d *Docker) gatherContainer(
 		"container_version": imageVersion,
 	}
 
-	if !d.containerFilter.Match(cname) {
-		return nil
-	}
-
 	ctx, cancel := context.WithTimeout(context.Background(), d.Timeout.Duration)
 	defer cancel()
 	r, err := d.client.ContainerStats(ctx, container.ID, false)
@@ -411,6 +420,11 @@ func (d *Docker) gatherContainer(
 	}
 	daemonOSType := r.OSType
 
+	// use common (printed at `docker ps`) name for container
+	if cname != strings.TrimPrefix(v.Name, "/") && v.Name != "" {
+		tags["container_name"] = strings.TrimPrefix(v.Name, "/")
+	}
+
 	// Add labels to tags
 	for k, label := range container.Labels {
 		if d.labelFilter.Match(k) {
@@ -461,12 +475,12 @@ func (d *Docker) gatherContainer(
 		acc.AddFields("docker_container_health", healthfields, tags, time.Now())
 	}
 
-	gatherContainerStats(v, acc, tags, container.ID, d.PerDevice, d.Total, daemonOSType)
+	parseContainerStats(v, acc, tags, container.ID, d.PerDevice, d.Total, daemonOSType)
 
 	return nil
 }
 
-func gatherContainerStats(
+func parseContainerStats(
 	stat *types.StatsJSON,
 	acc telegraf.Accumulator,
 	tags map[string]string,

plugins/inputs/docker/docker_test.go

@@ -107,7 +107,7 @@ func TestDockerGatherContainerStats(t *testing.T) {
 		"container_image": "redis/image",
 	}
 
-	gatherContainerStats(stats, &acc, tags, "123456789", true, true, "linux")
+	parseContainerStats(stats, &acc, tags, "123456789", true, true, "linux")
 
 	// test docker_container_net measurement
 	netfields := map[string]interface{}{

plugins/inputs/http_listener/http_listener.go

@@ -343,6 +343,9 @@ func (h *HTTPListener) serveWrite(res http.ResponseWriter, req *http.Request) {
 }
 
 func (h *HTTPListener) parse(b []byte, t time.Time, precision string) error {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
 	h.handler.SetTimePrecision(getPrecisionMultiplier(precision))
 	h.handler.SetTimeFunc(func() time.Time { return t })
 	metrics, err := h.parser.Parse(b)

plugins/inputs/ipmi_sensor/ipmi.go

@@ -5,6 +5,7 @@ import (
 	"os/exec"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/influxdata/telegraf"
@@ -61,13 +62,18 @@ func (m *Ipmi) Gather(acc telegraf.Accumulator) error {
 	}
 
 	if len(m.Servers) > 0 {
+		wg := sync.WaitGroup{}
 		for _, server := range m.Servers {
-			err := m.parse(acc, server)
-			if err != nil {
-				acc.AddError(err)
-				continue
-			}
+			wg.Add(1)
+			go func(a telegraf.Accumulator, s string) {
+				defer wg.Done()
+				err := m.parse(a, s)
+				if err != nil {
+					a.AddError(err)
+				}
+			}(acc, server)
 		}
+		wg.Wait()
 	} else {
 		err := m.parse(acc, "")
 		if err != nil {

plugins/inputs/mongodb/mongodb_data.go

@@ -31,28 +31,35 @@ func NewMongodbData(statLine *StatLine, tags map[string]string) *MongodbData {
 }
 
 var DefaultStats = map[string]string{
-	"inserts_per_sec":     "Insert",
-	"queries_per_sec":     "Query",
-	"updates_per_sec":     "Update",
-	"deletes_per_sec":     "Delete",
-	"getmores_per_sec":    "GetMore",
-	"commands_per_sec":    "Command",
-	"flushes_per_sec":     "Flushes",
-	"vsize_megabytes":     "Virtual",
-	"resident_megabytes":  "Resident",
-	"queued_reads":        "QueuedReaders",
-	"queued_writes":       "QueuedWriters",
-	"active_reads":        "ActiveReaders",
-	"active_writes":       "ActiveWriters",
-	"net_in_bytes":        "NetIn",
-	"net_out_bytes":       "NetOut",
-	"open_connections":    "NumConnections",
-	"ttl_deletes_per_sec": "DeletedDocuments",
-	"ttl_passes_per_sec":  "Passes",
-	"cursor_timed_out":    "TimedOutC",
-	"cursor_no_timeout":   "NoTimeoutC",
-	"cursor_pinned":       "PinnedC",
-	"cursor_total":        "TotalC",
+	"inserts_per_sec":           "Insert",
+	"queries_per_sec":           "Query",
+	"updates_per_sec":           "Update",
+	"deletes_per_sec":           "Delete",
+	"getmores_per_sec":          "GetMore",
+	"commands_per_sec":          "Command",
+	"flushes_per_sec":           "Flushes",
+	"vsize_megabytes":           "Virtual",
+	"resident_megabytes":        "Resident",
+	"queued_reads":              "QueuedReaders",
+	"queued_writes":             "QueuedWriters",
+	"active_reads":              "ActiveReaders",
+	"active_writes":             "ActiveWriters",
+	"net_in_bytes":              "NetIn",
+	"net_out_bytes":             "NetOut",
+	"open_connections":          "NumConnections",
+	"ttl_deletes_per_sec":       "DeletedDocuments",
+	"ttl_passes_per_sec":        "Passes",
+	"cursor_timed_out":          "TimedOutC",
+	"cursor_no_timeout":         "NoTimeoutC",
+	"cursor_pinned":             "PinnedC",
+	"cursor_total":              "TotalC",
+	"document_deleted":          "DeletedD",
+	"document_inserted":         "InsertedD",
+	"document_returned":         "ReturnedD",
+	"document_updated":          "UpdatedD",
+	"connections_current":       "CurrentC",
+	"connections_available":     "AvailableC",
+	"connections_total_created": "TotalCreatedC",
 }
 
 var DefaultReplStats = map[string]string{

plugins/inputs/mongodb/mongodb_data_test.go

@@ -38,6 +38,13 @@ func TestAddNonReplStats(t *testing.T) {
 			NoTimeoutC:       0,
 			PinnedC:          0,
 			TotalC:           0,
+			DeletedD:         0,
+			InsertedD:        0,
+			ReturnedD:        0,
+			UpdatedD:         0,
+			CurrentC:         0,
+			AvailableC:       0,
+			TotalCreatedC:    0,
 		},
 		tags,
 	)
@@ -182,43 +189,50 @@ func TestStateTag(t *testing.T) {
 	d.AddDefaultStats()
 	d.flush(&acc)
 	fields := map[string]interface{}{
-		"active_reads":          int64(0),
-		"active_writes":         int64(0),
-		"commands_per_sec":      int64(0),
-		"deletes_per_sec":       int64(0),
-		"flushes_per_sec":       int64(0),
-		"getmores_per_sec":      int64(0),
-		"inserts_per_sec":       int64(0),
-		"member_status":         "PRI",
-		"state":                 "PRIMARY",
-		"net_in_bytes":          int64(0),
-		"net_out_bytes":         int64(0),
-		"open_connections":      int64(0),
-		"queries_per_sec":       int64(0),
-		"queued_reads":          int64(0),
-		"queued_writes":         int64(0),
-		"repl_commands_per_sec": int64(0),
-		"repl_deletes_per_sec":  int64(0),
-		"repl_getmores_per_sec": int64(0),
-		"repl_inserts_per_sec":  int64(0),
-		"repl_queries_per_sec":  int64(0),
-		"repl_updates_per_sec":  int64(0),
-		"repl_lag":              int64(0),
-		"repl_oplog_window_sec": int64(0),
-		"resident_megabytes":    int64(0),
-		"updates_per_sec":       int64(0),
-		"vsize_megabytes":       int64(0),
-		"ttl_deletes_per_sec":   int64(0),
-		"ttl_passes_per_sec":    int64(0),
-		"jumbo_chunks":          int64(0),
-		"total_in_use":          int64(0),
-		"total_available":       int64(0),
-		"total_created":         int64(0),
-		"total_refreshing":      int64(0),
-		"cursor_timed_out":      int64(0),
-		"cursor_no_timeout":     int64(0),
-		"cursor_pinned":         int64(0),
-		"cursor_total":          int64(0),
+		"active_reads":              int64(0),
+		"active_writes":             int64(0),
+		"commands_per_sec":          int64(0),
+		"deletes_per_sec":           int64(0),
+		"flushes_per_sec":           int64(0),
+		"getmores_per_sec":          int64(0),
+		"inserts_per_sec":           int64(0),
+		"member_status":             "PRI",
+		"state":                     "PRIMARY",
+		"net_in_bytes":              int64(0),
+		"net_out_bytes":             int64(0),
+		"open_connections":          int64(0),
+		"queries_per_sec":           int64(0),
+		"queued_reads":              int64(0),
+		"queued_writes":             int64(0),
+		"repl_commands_per_sec":     int64(0),
+		"repl_deletes_per_sec":      int64(0),
+		"repl_getmores_per_sec":     int64(0),
+		"repl_inserts_per_sec":      int64(0),
+		"repl_queries_per_sec":      int64(0),
+		"repl_updates_per_sec":      int64(0),
+		"repl_lag":                  int64(0),
+		"repl_oplog_window_sec":     int64(0),
+		"resident_megabytes":        int64(0),
+		"updates_per_sec":           int64(0),
+		"vsize_megabytes":           int64(0),
+		"ttl_deletes_per_sec":       int64(0),
+		"ttl_passes_per_sec":        int64(0),
+		"jumbo_chunks":              int64(0),
+		"total_in_use":              int64(0),
+		"total_available":           int64(0),
+		"total_created":             int64(0),
+		"total_refreshing":          int64(0),
+		"cursor_timed_out":          int64(0),
+		"cursor_no_timeout":         int64(0),
+		"cursor_pinned":             int64(0),
+		"cursor_total":              int64(0),
+		"document_deleted":          int64(0),
+		"document_inserted":         int64(0),
+		"document_returned":         int64(0),
+		"document_updated":          int64(0),
+		"connections_current":       int64(0),
+		"connections_available":     int64(0),
+		"connections_total_created": int64(0),
 	}
 	acc.AssertContainsTaggedFields(t, "mongodb", fields, stateTags)
 }

plugins/inputs/mongodb/mongostat.go

@@ -225,7 +225,7 @@ type FlushStats struct {
 type ConnectionStats struct {
 	Current      int64 `bson:"current"`
 	Available    int64 `bson:"available"`
-	TotalCreated int64 `bson:"totalCreated"`
+	TotalCreated int64 `bson:"total_created"`
 }
 
 // DurTiming stores information related to journaling.
@@ -289,8 +289,9 @@ type OpcountStats struct {
 
 // MetricsStats stores information related to metrics
 type MetricsStats struct {
-	TTL    *TTLStats    `bson:"ttl"`
-	Cursor *CursorStats `bson:"cursor"`
+	TTL      *TTLStats      `bson:"ttl"`
+	Cursor   *CursorStats   `bson:"cursor"`
+	Document *DocumentStats `bson:"document"`
 }
 
 // TTLStats stores information related to documents with a ttl index.
@@ -305,6 +306,14 @@ type CursorStats struct {
 	Open     *OpenCursorStats `bson:"open"`
 }
 
+// DocumentStats stores information related to document metrics.
+type DocumentStats struct {
+	Deleted  int64 `bson:"deleted"`
+	Inserted int64 `bson:"inserted"`
+	Returned int64 `bson:"returned"`
+	Updated  int64 `bson:"updated"`
+}
+
 // OpenCursorStats stores information related to open cursor metrics
 type OpenCursorStats struct {
 	NoTimeout int64 `bson:"noTimeout"`
@@ -457,6 +466,12 @@ type StatLine struct {
 	TimedOutC                   int64
 	NoTimeoutC, PinnedC, TotalC int64
 
+	// Document fields
+	DeletedD, InsertedD, ReturnedD, UpdatedD int64
+
+	// Connection fields
+	CurrentC, AvailableC, TotalCreatedC int64
+
 	// Collection locks (3.0 mmap only)
 	CollectionLocks *CollectionLockStatus
 

plugins/inputs/procstat/README.md

@@ -1,6 +1,8 @@
 # Procstat Input Plugin
 
 The procstat plugin can be used to monitor the system resource usage of one or more processes.
+The procstat_lookup metric displays the query information, 
+specifically the number of PIDs returned on a search
 
 Processes can be selected for monitoring using one of several methods:
 - pidfile
@@ -127,7 +129,18 @@ implemented as a WMI query.  The pattern allows fuzzy matching using only
     - voluntary_context_switches (int)
     - write_bytes (int, *telegraf* may need to be ran as **root**)
     - write_count (int, *telegraf* may need to be ran as **root**)
-
+- procstat_lookup
+  - tags:
+    - exe (string)
+    - pid_finder (string)
+    - pid_file (string)
+    - pattern (string)
+    - prefix (string)
+    - user (string)
+    - systemd_unit (string)
+    - cgroup (string)
+  - fields:
+    - pid_count (int)
 *NOTE: Resource limit > 2147483647 will be reported as 2147483647.*
 
 ### Example Output:

plugins/inputs/system/DISKIO_README.md

@@ -107,13 +107,13 @@ requests that are in the queue but not yet issued to the device driver.
 
 #### Calculate percent IO utilization per disk and host:
 ```
-SELECT derivative(last("io_time"),1ms) FROM "diskio" WHERE time > now() - 30m GROUP BY "host","name",time(60s)
+SELECT non_negative_derivative(last("io_time"),1ms) FROM "diskio" WHERE time > now() - 30m GROUP BY "host","name",time(60s)
 ```
 
 #### Calculate average queue depth:
 `iops_in_progress` will give you an instantaneous value. This will give you the average between polling intervals.
 ```
-SELECT derivative(last("weighted_io_time",1ms)) from "diskio" WHERE time > now() - 30m GROUP BY "host","name",time(60s)
+SELECT non_negative_derivative(last("weighted_io_time",1ms)) from "diskio" WHERE time > now() - 30m GROUP BY "host","name",time(60s)
 ```
 
 ### Example Output:

plugins/inputs/system/SWAP_README.md

@@ -2,7 +2,7 @@
 
 The swap plugin collects system swap metrics.
 
-For a more information on what swap memory is, read [All about Linux swap space](https://www.linux.com/news/all-about-linux-swap-space).
+For more information on what swap memory is, read [All about Linux swap space](https://www.linux.com/news/all-about-linux-swap-space).
 
 ### Configuration:
 

plugins/processors/all/all.go

@@ -2,6 +2,7 @@ package all
 
 import (
 	_ "github.com/influxdata/telegraf/plugins/processors/converter"
+	_ "github.com/influxdata/telegraf/plugins/processors/enum"
 	_ "github.com/influxdata/telegraf/plugins/processors/override"
 	_ "github.com/influxdata/telegraf/plugins/processors/printer"
 	_ "github.com/influxdata/telegraf/plugins/processors/regex"

plugins/processors/enum/README.md

@@ -0,0 +1,33 @@
+# Enum Processor Plugin
+
+The Enum Processor allows the configuration of value mappings for metric fields.
+The main use-case for this is to rewrite status codes such as _red_, _amber_ and
+_green_ by numeric values such as 0, 1, 2. The plugin supports string and bool
+types for the field values. Multiple Fields can be configured with separate
+value mappings for each field. Default mapping values can be configured to be
+used for all values, which are not contained in the value_mappings. The
+processor supports explicit configuration of a destination field. By default the
+source field is overwritten.
+
+### Configuration:
+
+```toml
+[[processors.enum]]
+  [[processors.enum.fields]]
+    ## Name of the field to map
+    source = "name"
+
+    ## Destination field to be used for the mapped value.  By default the source
+    ## field is used, overwriting the original value.
+    # destination = "mapped"
+
+    ## 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.fields.value_mappings]
+      value1 = 1
+      value2 = 2
+```

plugins/processors/enum/enum.go

@@ -0,0 +1,104 @@
+package enum
+
+import (
+	"strconv"
+
+	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/plugins/processors"
+)
+
+var sampleConfig = `
+  [[processors.enum.fields]]
+    ## Name of the field to map
+    source = "name"
+
+    ## Destination field to be used for the mapped value.  By default the source
+    ## field is used, overwriting the original value.
+    # destination = "mapped"
+
+    ## 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.fields.value_mappings]
+      value1 = 1
+      value2 = 2
+`
+
+type EnumMapper struct {
+	Fields []Mapping
+}
+
+type Mapping struct {
+	Source        string
+	Destination   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.Fields {
+		if originalValue, isPresent := metric.GetField(mapping.Source); isPresent == true {
+			if adjustedValue, isString := adjustBoolValue(originalValue).(string); isString == true {
+				if mappedValue, isMappedValuePresent := mapping.mapValue(adjustedValue); isMappedValuePresent == true {
+					writeField(metric, mapping.getDestination(), mappedValue)
+				}
+			}
+		}
+	}
+	return metric
+}
+
+func adjustBoolValue(in interface{}) interface{} {
+	if mappedBool, isBool := in.(bool); isBool == true {
+		return strconv.FormatBool(mappedBool)
+	}
+	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.Destination != "" {
+		return mapping.Destination
+	}
+	return mapping.Source
+}
+
+func writeField(metric telegraf.Metric, name string, value interface{}) {
+	if metric.HasField(name) {
+		metric.RemoveField(name)
+	}
+	metric.AddField(name, value)
+}
+
+func init() {
+	processors.Add("enum", func() telegraf.Processor {
+		return &EnumMapper{}
+	})
+}

plugins/processors/enum/enum_test.go

@@ -0,0 +1,106 @@
+package enum
+
+import (
+	"testing"
+	"time"
+
+	"github.com/influxdata/telegraf"
+	"github.com/influxdata/telegraf/metric"
+	"github.com/stretchr/testify/assert"
+)
+
+func createTestMetric() telegraf.Metric {
+	metric, _ := metric.New("m1",
+		map[string]string{"tag": "tag_value"},
+		map[string]interface{}{
+			"string_value": "test",
+			"int_value":    int(13),
+			"true_value":   true,
+		},
+		time.Now(),
+	)
+	return metric
+}
+
+func calculateProcessedValues(mapper EnumMapper, metric telegraf.Metric) map[string]interface{} {
+	processed := mapper.Apply(metric)
+	return processed[0].Fields()
+}
+
+func assertFieldValue(t *testing.T, expected interface{}, field string, fields map[string]interface{}) {
+	value, present := fields[field]
+	assert.True(t, present, "value of field '"+field+"' was not present")
+	assert.EqualValues(t, expected, value)
+}
+
+func TestRetainsMetric(t *testing.T) {
+	mapper := EnumMapper{}
+	source := createTestMetric()
+
+	target := mapper.Apply(source)[0]
+	fields := target.Fields()
+
+	assertFieldValue(t, "test", "string_value", fields)
+	assertFieldValue(t, 13, "int_value", fields)
+	assertFieldValue(t, true, "true_value", fields)
+	assert.Equal(t, "m1", target.Name())
+	assert.Equal(t, source.Tags(), target.Tags())
+	assert.Equal(t, source.Time(), target.Time())
+}
+
+func TestMapsSingleStringValue(t *testing.T) {
+	mapper := EnumMapper{Fields: []Mapping{{Source: "string_value", ValueMappings: map[string]interface{}{"test": int64(1)}}}}
+
+	fields := calculateProcessedValues(mapper, createTestMetric())
+
+	assertFieldValue(t, 1, "string_value", fields)
+}
+
+func TestNoFailureOnMappingsOnNonStringValuedFields(t *testing.T) {
+	mapper := EnumMapper{Fields: []Mapping{{Source: "int_value", ValueMappings: map[string]interface{}{"13i": int64(7)}}}}
+
+	fields := calculateProcessedValues(mapper, createTestMetric())
+
+	assertFieldValue(t, 13, "int_value", fields)
+}
+
+func TestMapSingleBoolValue(t *testing.T) {
+	mapper := EnumMapper{Fields: []Mapping{{Source: "true_value", ValueMappings: map[string]interface{}{"true": int64(1)}}}}
+
+	fields := calculateProcessedValues(mapper, createTestMetric())
+
+	assertFieldValue(t, 1, "true_value", fields)
+}
+
+func TestMapsToDefaultValueOnUnknownSourceValue(t *testing.T) {
+	mapper := EnumMapper{Fields: []Mapping{{Source: "string_value", Default: int64(42), ValueMappings: map[string]interface{}{"other": int64(1)}}}}
+
+	fields := calculateProcessedValues(mapper, createTestMetric())
+
+	assertFieldValue(t, 42, "string_value", fields)
+}
+
+func TestDoNotMapToDefaultValueKnownSourceValue(t *testing.T) {
+	mapper := EnumMapper{Fields: []Mapping{{Source: "string_value", Default: int64(42), ValueMappings: map[string]interface{}{"test": int64(1)}}}}
+
+	fields := calculateProcessedValues(mapper, createTestMetric())
+
+	assertFieldValue(t, 1, "string_value", fields)
+}
+
+func TestNoMappingWithoutDefaultOrDefinedMappingValue(t *testing.T) {
+	mapper := EnumMapper{Fields: []Mapping{{Source: "string_value", ValueMappings: map[string]interface{}{"other": int64(1)}}}}
+
+	fields := calculateProcessedValues(mapper, createTestMetric())
+
+	assertFieldValue(t, "test", "string_value", fields)
+}
+
+func TestWritesToDestination(t *testing.T) {
+	mapper := EnumMapper{Fields: []Mapping{{Source: "string_value", Destination: "string_code", ValueMappings: map[string]interface{}{"test": int64(1)}}}}
+
+	fields := calculateProcessedValues(mapper, createTestMetric())
+
+	assertFieldValue(t, "test", "string_value", fields)
+	assertFieldValue(t, 1, "string_code", fields)
+}