Support optional empty strings and fix the separator field in the con…

…cat secret (#1235)

pkg/sdk/logging/model/filter/concat.go

@@ -40,7 +40,8 @@ type Concat struct {
 	// Specify field name in the record to parse. If you leave empty the Container Runtime default will be used.
 	Key string `json:"key,omitempty"`
 	//The separator of lines. (default: "\n")
-	Separator string `json:"separator,omitempty"`
+	// +kubebuilder:validation:Optional
+	Separator *string `json:"separator,omitempty" plugin:"default:\"\\n\""`
 	//The number of lines. This is exclusive with multiline_start_regex.
 	NLines int `json:"n_lines,omitempty"`
 	//The regexp to match beginning of multiline. This is exclusive with n_lines.

pkg/sdk/logging/model/filter/concat_test.go

@@ -24,23 +24,49 @@ import (
 )
 
 func TestConcat(t *testing.T) {
-	CONFIG := []byte(`
+	testData := []struct {
+		Config   []byte
+		Expected string
+	}{
+		{
+			Config: []byte(`
 partial_key: "partial_message"
-separator: ""
 n_lines: 10
-
-`)
-	expected := `
+`),
+			Expected: `
 <filter **>
   @type concat
   @id test
   key message
   n_lines 10
   partial_key partial_message
+  separator "\n"
 </filter>
-`
-	parser := &filter.Concat{}
-	require.NoError(t, yaml.Unmarshal(CONFIG, parser))
-	test := render.NewOutputPluginTest(t, parser)
-	test.DiffResult(expected)
+			`,
+		},
+		{
+			Config: []byte(`
+partial_key: "partial_message"
+n_lines: 10
+separator: ""
+`),
+			Expected: `
+<filter **>
+  @type concat
+  @id test
+  key message
+  n_lines 10
+  partial_key partial_message
+  separator
+</filter>
+			`,
+		},
+	}
+
+	for _, d := range testData {
+		parser := &filter.Concat{}
+		require.NoError(t, yaml.Unmarshal(d.Config, parser))
+		test := render.NewOutputPluginTest(t, parser)
+		test.DiffResult(d.Expected)
+	}
 }

pkg/sdk/logging/model/types/stringmaps.go

@@ -117,14 +117,19 @@ func (s *StructToStringMapper) processField(field reflect.StructField, value ref
 		}
 	}
 
+	var isPointer, isNil bool
 	if value.Kind() == reflect.Ptr {
+		isPointer = true
+		if value.IsNil() {
+			isNil = true
+		}
 		value = value.Elem()
 	}
 
 	switch value.Kind() { // nolint:exhaustive
 	case reflect.String, reflect.Int, reflect.Bool:
 		val := fmt.Sprintf("%v", value.Interface())
-		if val == "" {
+		if (isPointer && isNil) || (!isPointer && val == "") {
 			// check if default has been set and use it
 			if ok, def := pluginTagOpts.ValueForPrefix("default:"); ok {
 				val = def

pkg/sdk/logging/model/types/stringmaps_test.go

@@ -24,6 +24,7 @@ import (
 	"emperror.dev/errors"
 	"github.com/banzaicloud/logging-operator/pkg/sdk/logging/model/types"
 	"github.com/banzaicloud/operator-tools/pkg/secret"
+	"github.com/banzaicloud/operator-tools/pkg/utils"
 	corev1 "k8s.io/api/core/v1"
 )
 
@@ -59,20 +60,29 @@ func TestRequiredMeansItCannotEvenBeEmpty(t *testing.T) {
 
 func TestJsonTagsWithDefaultsAndOmitempty(t *testing.T) {
 	type Asd struct {
-		Field1 string `json:"field1"`
-		Field2 string `json:"field2,omitempty" plugin:"default:http://asdf and some space"`
-		Field3 string `json:"field3,omitempty"`
-	}
-	actual, err := types.NewStructToStringMapper(secret.NewSecretLoader(nil, "", "", nil)).StringsMap(Asd{Field1: "value"})
+		Field1 string  `json:"field1"`
+		Field2 string  `json:"field2,omitempty" plugin:"default:http://asdf and some space"`
+		Field3 string  `json:"field3,omitempty"`
+		Field4 *string `json:"field4,omitempty" plugin:"default:nonempty"`
+		Field5 *string `json:"field5,omitempty" plugin:"default:nonempty"`
+	}
+	actual, err := types.NewStructToStringMapper(secret.NewSecretLoader(nil, "", "", nil)).StringsMap(
+		Asd{
+			Field1: "value",
+			Field4: utils.StringPointer(""), // looks like empty, but it's not, we expect this to be set
+			Field5: nil,                     // empty for real
+		})
 	if err != nil {
 		t.Fatalf("%+v", err)
 	}
 	expected := map[string]string{
 		"field1": "value",
 		"field2": "http://asdf and some space",
+		"field4": "",
+		"field5": "nonempty",
 	}
 	if !reflect.DeepEqual(expected, actual) {
-		t.Fatalf("failed to match expected %+v with %+v", expected, actual)
+		t.Fatalf("failed to match\nexpected:\n%+v\n\nactual:\n%+v", expected, actual)
 	}
 }