Add (*MapStr).DeepUpdate (#4090)

Add DeepUpdate to MapStr for recursive-deep updating an event.

libbeat/common/mapstr.go

@@ -42,6 +42,40 @@ func (m MapStr) Update(d MapStr) {
 	}
 }
 
+// DeepUpdate recursively copies the key-value pairs from d to this map.
+// If the key is present and a map as well, the sub-map will be updated recursively
+// via DeepUpdate.
+func (m MapStr) DeepUpdate(d MapStr) {
+	for k, v := range d {
+		switch val := v.(type) {
+		case map[string]interface{}:
+			m[k] = deepUpdateValue(m[k], MapStr(val))
+		case MapStr:
+			m[k] = deepUpdateValue(m[k], val)
+		default:
+			m[k] = v
+		}
+	}
+}
+
+func deepUpdateValue(old interface{}, val MapStr) interface{} {
+	if old == nil {
+		return val
+	}
+
+	switch sub := old.(type) {
+	case MapStr:
+		sub.DeepUpdate(val)
+		return sub
+	case map[string]interface{}:
+		tmp := MapStr(sub)
+		tmp.DeepUpdate(val)
+		return tmp
+	default:
+		return val
+	}
+}
+
 // Delete deletes the given key from the map.
 func (m MapStr) Delete(key string) error {
 	_, err := walkMap(key, m, opDelete)

libbeat/common/mapstr_test.go

@@ -3,6 +3,7 @@
 package common
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -25,6 +26,48 @@ func TestMapStrUpdate(t *testing.T) {
 	assert.Equal(a, MapStr{"a": 1, "b": 3, "c": 4})
 }
 
+func TestMapStrDeepUpdate(t *testing.T) {
+	tests := []struct {
+		a, b, expected MapStr
+	}{
+		{
+			MapStr{"a": 1},
+			MapStr{"b": 2},
+			MapStr{"a": 1, "b": 2},
+		},
+		{
+			MapStr{"a": 1},
+			MapStr{"a": 2},
+			MapStr{"a": 2},
+		},
+		{
+			MapStr{"a": 1},
+			MapStr{"a": MapStr{"b": 1}},
+			MapStr{"a": MapStr{"b": 1}},
+		},
+		{
+			MapStr{"a": MapStr{"b": 1}},
+			MapStr{"a": MapStr{"c": 2}},
+			MapStr{"a": MapStr{"b": 1, "c": 2}},
+		},
+		{
+			MapStr{"a": MapStr{"b": 1}},
+			MapStr{"a": 1},
+			MapStr{"a": 1},
+		},
+	}
+
+	for i, test := range tests {
+		a, b, expected := test.a, test.b, test.expected
+		name := fmt.Sprintf("%v: %v + %v = %v", i, a, b, expected)
+
+		t.Run(name, func(t *testing.T) {
+			a.DeepUpdate(b)
+			assert.Equal(t, expected, a)
+		})
+	}
+}
+
 func TestMapStrUnion(t *testing.T) {
 	assert := assert.New(t)