Add to periodic stats print in tapper (#220)

.github/workflows/validations.yaml

@@ -1,4 +1,4 @@
-name: Validations
+name: validations
 on:
   pull_request:
     branches:

agent/Makefile

@@ -1,2 +1,2 @@
 test: ## Run agent tests.
-	@go test ./... -race -coverprofile=coverage.out -covermode=atomic
+	@go test ./... -coverpkg=./... -race -coverprofile=coverage.out -covermode=atomic

agent/pkg/providers/stats_provider_test.go

@@ -18,9 +18,7 @@ func TestEntryAddedCount(t *testing.T) {
 	tests := []int{1, 5, 10, 100, 500, 1000}
 
 	for _, entriesCount := range tests {
-		t.Run(fmt.Sprintf("EntriesCount%v", entriesCount), func(t *testing.T) {
-			t.Cleanup(providers.ResetGeneralStats)
-
+		t.Run(fmt.Sprintf("%d", entriesCount), func(t *testing.T) {
 			for i := 0; i < entriesCount; i++ {
 				providers.EntryAdded()
 			}
@@ -30,6 +28,8 @@ func TestEntryAddedCount(t *testing.T) {
 			if entriesStats.EntriesCount != entriesCount {
 				t.Errorf("unexpected result - expected: %v, actual: %v", entriesCount, entriesStats.EntriesCount)
 			}
+
+			t.Cleanup(providers.ResetGeneralStats)
 		})
 	}
 }

cli/Makefile

@@ -41,4 +41,4 @@ clean: ## Clean all build artifacts.
 	rm -rf ./bin/*
 
 test: ## Run cli tests.
-	@go test ./... -race -coverprofile=coverage.out -covermode=atomic
+	@go test ./... -coverpkg=./... -race -coverprofile=coverage.out -covermode=atomic

cli/config/config_internal_test.go

@@ -1,6 +1,7 @@
 package config
 
 import (
+	"fmt"
 	"reflect"
 	"testing"
 )
@@ -22,186 +23,226 @@ type SectionMock struct {
 	Test string `yaml:"test"`
 }
 
+type FieldSetValues struct {
+	SetValues  []string
+	FieldName  string
+	FieldValue interface{}
+}
+
 func TestMergeSetFlagNoSeparator(t *testing.T) {
-	tests := [][]string{{""}, {"t"}, {"", "t"}, {"t", "test", "test:true"}, {"test", "test:true", "testing!", "true"}}
+	tests := []struct {
+		Name      string
+		SetValues []string
+	}{
+		{Name: "empty value", SetValues: []string{""}},
+		{Name: "single char", SetValues: []string{"t"}},
+		{Name: "combine empty value and single char", SetValues: []string{"", "t"}},
+		{Name: "two values without separator", SetValues: []string{"test", "test:true"}},
+		{Name: "four values without separator", SetValues: []string{"test", "test:true", "testing!", "true"}},
+	}
 
-	for _, setValues := range tests {
-		configMock := ConfigMock{}
-		configMockElemValue := reflect.ValueOf(&configMock).Elem()
+	for _, test := range tests {
+		t.Run(test.Name, func(t *testing.T) {
+			configMock := ConfigMock{}
+			configMockElemValue := reflect.ValueOf(&configMock).Elem()
 
-		err := mergeSetFlag(configMockElemValue, setValues)
+			err := mergeSetFlag(configMockElemValue, test.SetValues)
 
-		if err == nil {
-			t.Errorf("unexpected unhandled error - setValues: %v", setValues)
-			continue
-		}
-
-		for i := 0; i < configMockElemValue.NumField(); i++ {
-			currentField := configMockElemValue.Type().Field(i)
-			currentFieldByName := configMockElemValue.FieldByName(currentField.Name)
-
-			if !currentFieldByName.IsZero() {
-				t.Errorf("unexpected value with not default value - setValues: %v", setValues)
+			if err == nil {
+				t.Errorf("unexpected unhandled error - SetValues: %v", test.SetValues)
+				return
 			}
-		}
+
+			for i := 0; i < configMockElemValue.NumField(); i++ {
+				currentField := configMockElemValue.Type().Field(i)
+				currentFieldByName := configMockElemValue.FieldByName(currentField.Name)
+
+				if !currentFieldByName.IsZero() {
+					t.Errorf("unexpected value with not default value - SetValues: %v", test.SetValues)
+				}
+			}
+		})
 	}
 }
 
 func TestMergeSetFlagInvalidFlagName(t *testing.T) {
-	tests := [][]string{{"invalid_flag=true"}, {"section.invalid_flag=test"}, {"section=test"}, {"=true"}, {"invalid_flag=true", "config.invalid_flag=test", "section=test", "=true"}}
+	tests := []struct {
+		Name      string
+		SetValues []string
+	}{
+		{Name: "invalid flag name", SetValues: []string{"invalid_flag=true"}},
+		{Name: "invalid flag name inside section struct", SetValues: []string{"section.invalid_flag=test"}},
+		{Name: "flag name is a struct", SetValues: []string{"section=test"}},
+		{Name: "empty flag name", SetValues: []string{"=true"}},
+		{Name: "four tests combined", SetValues: []string{"invalid_flag=true", "config.invalid_flag=test", "section=test", "=true"}},
+	}
 
-	for _, setValues := range tests {
-		configMock := ConfigMock{}
-		configMockElemValue := reflect.ValueOf(&configMock).Elem()
+	for _, test := range tests {
+		t.Run(test.Name, func(t *testing.T) {
+			configMock := ConfigMock{}
+			configMockElemValue := reflect.ValueOf(&configMock).Elem()
 
-		err := mergeSetFlag(configMockElemValue, setValues)
+			err := mergeSetFlag(configMockElemValue, test.SetValues)
 
-		if err == nil {
-			t.Errorf("unexpected unhandled error - setValues: %v", setValues)
-			continue
-		}
-
-		for i := 0; i < configMockElemValue.NumField(); i++ {
-			currentField := configMockElemValue.Type().Field(i)
-			currentFieldByName := configMockElemValue.FieldByName(currentField.Name)
-
-			if !currentFieldByName.IsZero() {
-				t.Errorf("unexpected case - setValues: %v", setValues)
+			if err == nil {
+				t.Errorf("unexpected unhandled error - SetValues: %v", test.SetValues)
+				return
 			}
-		}
+
+			for i := 0; i < configMockElemValue.NumField(); i++ {
+				currentField := configMockElemValue.Type().Field(i)
+				currentFieldByName := configMockElemValue.FieldByName(currentField.Name)
+
+				if !currentFieldByName.IsZero() {
+					t.Errorf("unexpected case - SetValues: %v", test.SetValues)
+				}
+			}
+		})
 	}
 }
 
 func TestMergeSetFlagInvalidFlagValue(t *testing.T) {
-	tests := [][]string{{"int-field=true"}, {"bool-field:5"}, {"uint-field=-1"}, {"int-slice-field=true"}, {"bool-slice-field=5"}, {"uint-slice-field=-1"}, {"int-field=6", "int-field=66"}}
+	tests := []struct {
+		Name      string
+		SetValues []string
+	}{
+		{Name: "bool value to int field", SetValues: []string{"int-field=true"}},
+		{Name: "int value to bool field", SetValues: []string{"bool-field:5"}},
+		{Name: "int value to uint field", SetValues: []string{"uint-field=-1"}},
+		{Name: "bool value to int slice field", SetValues: []string{"int-slice-field=true"}},
+		{Name: "int value to bool slice field", SetValues: []string{"bool-slice-field=5"}},
+		{Name: "int value to uint slice field", SetValues: []string{"uint-slice-field=-1"}},
+		{Name: "int slice value to int field", SetValues: []string{"int-field=6", "int-field=66"}},
+	}
 
-	for _, setValues := range tests {
-		configMock := ConfigMock{}
-		configMockElemValue := reflect.ValueOf(&configMock).Elem()
+	for _, test := range tests {
+		t.Run(test.Name, func(t *testing.T) {
+			configMock := ConfigMock{}
+			configMockElemValue := reflect.ValueOf(&configMock).Elem()
 
-		err := mergeSetFlag(configMockElemValue, setValues)
+			err := mergeSetFlag(configMockElemValue, test.SetValues)
 
-		if err == nil {
-			t.Errorf("unexpected unhandled error - setValues: %v", setValues)
-			continue
-		}
-
-		for i := 0; i < configMockElemValue.NumField(); i++ {
-			currentField := configMockElemValue.Type().Field(i)
-			currentFieldByName := configMockElemValue.FieldByName(currentField.Name)
-
-			if !currentFieldByName.IsZero() {
-				t.Errorf("unexpected case - setValues: %v", setValues)
+			if err == nil {
+				t.Errorf("unexpected unhandled error - SetValues: %v", test.SetValues)
+				return
 			}
-		}
+
+			for i := 0; i < configMockElemValue.NumField(); i++ {
+				currentField := configMockElemValue.Type().Field(i)
+				currentFieldByName := configMockElemValue.FieldByName(currentField.Name)
+
+				if !currentFieldByName.IsZero() {
+					t.Errorf("unexpected case - SetValues: %v", test.SetValues)
+				}
+			}
+		})
 	}
 }
 
 func TestMergeSetFlagNotSliceValues(t *testing.T) {
-	tests := [][]struct {
-		SetValue   string
-		FieldName  string
-		FieldValue interface{}
+	tests := []struct {
+		Name            string
+		FieldsSetValues []FieldSetValues
 	}{
-		{{SetValue: "string-field=test", FieldName: "StringField", FieldValue: "test"}},
-		{{SetValue: "int-field=6", FieldName: "IntField", FieldValue: 6}},
-		{{SetValue: "bool-field=true", FieldName: "BoolField", FieldValue: true}},
-		{{SetValue: "uint-field=6", FieldName: "UintField", FieldValue: uint(6)}},
-		{
-			{SetValue: "string-field=test", FieldName: "StringField", FieldValue: "test"},
-			{SetValue: "int-field=6", FieldName: "IntField", FieldValue: 6},
-			{SetValue: "bool-field=true", FieldName: "BoolField", FieldValue: true},
-			{SetValue: "uint-field=6", FieldName: "UintField", FieldValue: uint(6)},
-		},
+		{Name: "string field", FieldsSetValues: []FieldSetValues{{SetValues: []string{"string-field=test"}, FieldName: "StringField", FieldValue: "test"}}},
+		{Name: "int field", FieldsSetValues: []FieldSetValues{{SetValues: []string{"int-field=6"}, FieldName: "IntField", FieldValue: 6}}},
+		{Name: "bool field", FieldsSetValues: []FieldSetValues{{SetValues: []string{"bool-field=true"}, FieldName: "BoolField", FieldValue: true}}},
+		{Name: "uint field", FieldsSetValues: []FieldSetValues{{SetValues: []string{"uint-field=6"}, FieldName: "UintField", FieldValue: uint(6)}}},
+		{Name: "four fields combined", FieldsSetValues: []FieldSetValues {
+			{SetValues: []string{"string-field=test"}, FieldName: "StringField", FieldValue: "test"},
+			{SetValues: []string{"int-field=6"}, FieldName: "IntField", FieldValue: 6},
+			{SetValues: []string{"bool-field=true"}, FieldName: "BoolField", FieldValue: true},
+			{SetValues: []string{"uint-field=6"}, FieldName: "UintField", FieldValue: uint(6)},
+		}},
 	}
 
 	for _, test := range tests {
-		configMock := ConfigMock{}
-		configMockElemValue := reflect.ValueOf(&configMock).Elem()
+		t.Run(test.Name, func(t *testing.T) {
+			configMock := ConfigMock{}
+			configMockElemValue := reflect.ValueOf(&configMock).Elem()
 
-		var setValues []string
-		for _, setValueInfo := range test {
-			setValues = append(setValues, setValueInfo.SetValue)
-		}
-
-		err := mergeSetFlag(configMockElemValue, setValues)
-
-		if err != nil {
-			t.Errorf("unexpected error result - err: %v", err)
-			continue
-		}
-
-		for _, setValueInfo := range test {
-			fieldValue := configMockElemValue.FieldByName(setValueInfo.FieldName).Interface()
-			if fieldValue != setValueInfo.FieldValue {
-				t.Errorf("unexpected result - expected: %v, actual: %v", setValueInfo.FieldValue, fieldValue)
+			var setValues []string
+			for _, fieldSetValues := range test.FieldsSetValues {
+				setValues = append(setValues, fieldSetValues.SetValues...)
 			}
-		}
+
+			err := mergeSetFlag(configMockElemValue, setValues)
+
+			if err != nil {
+				t.Errorf("unexpected error result - err: %v", err)
+				return
+			}
+
+			for _, fieldSetValues := range test.FieldsSetValues {
+				fieldValue := configMockElemValue.FieldByName(fieldSetValues.FieldName).Interface()
+				if fieldValue != fieldSetValues.FieldValue {
+					t.Errorf("unexpected result - expected: %v, actual: %v", fieldSetValues.FieldValue, fieldValue)
+				}
+			}
+		})
 	}
 }
 
 func TestMergeSetFlagSliceValues(t *testing.T) {
-	tests := [][]struct {
-		SetValues  []string
-		FieldName  string
-		FieldValue interface{}
+	tests := []struct {
+		Name            string
+		FieldsSetValues []FieldSetValues
 	}{
-		{{SetValues: []string{"string-slice-field=test"}, FieldName: "StringSliceField", FieldValue: []string{"test"}}},
-		{{SetValues: []string{"int-slice-field=6"}, FieldName: "IntSliceField", FieldValue: []int{6}}},
-		{{SetValues: []string{"bool-slice-field=true"}, FieldName: "BoolSliceField", FieldValue: []bool{true}}},
-		{{SetValues: []string{"uint-slice-field=6"}, FieldName: "UintSliceField", FieldValue: []uint{uint(6)}}},
-		{
+		{Name: "string slice field single value", FieldsSetValues: []FieldSetValues{{SetValues: []string{"string-slice-field=test"}, FieldName: "StringSliceField", FieldValue: []string{"test"}}}},
+		{Name: "int slice field single value", FieldsSetValues: []FieldSetValues{{SetValues: []string{"int-slice-field=6"}, FieldName: "IntSliceField", FieldValue: []int{6}}}},
+		{Name: "bool slice field single value", FieldsSetValues: []FieldSetValues{{SetValues: []string{"bool-slice-field=true"}, FieldName: "BoolSliceField", FieldValue: []bool{true}}}},
+		{Name: "uint slice field single value", FieldsSetValues: []FieldSetValues{{SetValues: []string{"uint-slice-field=6"}, FieldName: "UintSliceField", FieldValue: []uint{uint(6)}}}},
+		{Name: "four single value fields combined", FieldsSetValues: []FieldSetValues{
 			{SetValues: []string{"string-slice-field=test"}, FieldName: "StringSliceField", FieldValue: []string{"test"}},
 			{SetValues: []string{"int-slice-field=6"}, FieldName: "IntSliceField", FieldValue: []int{6}},
 			{SetValues: []string{"bool-slice-field=true"}, FieldName: "BoolSliceField", FieldValue: []bool{true}},
 			{SetValues: []string{"uint-slice-field=6"}, FieldName: "UintSliceField", FieldValue: []uint{uint(6)}},
-		},
-		{{SetValues: []string{"string-slice-field=test", "string-slice-field=test2"}, FieldName: "StringSliceField", FieldValue: []string{"test", "test2"}}},
-		{{SetValues: []string{"int-slice-field=6", "int-slice-field=66"}, FieldName: "IntSliceField", FieldValue: []int{6, 66}}},
-		{{SetValues: []string{"bool-slice-field=true", "bool-slice-field=false"}, FieldName: "BoolSliceField", FieldValue: []bool{true, false}}},
-		{{SetValues: []string{"uint-slice-field=6", "uint-slice-field=66"}, FieldName: "UintSliceField", FieldValue: []uint{uint(6), uint(66)}}},
-		{
+		}},
+		{Name: "string slice field two values", FieldsSetValues: []FieldSetValues{{SetValues: []string{"string-slice-field=test", "string-slice-field=test2"}, FieldName: "StringSliceField", FieldValue: []string{"test", "test2"}}}},
+		{Name: "int slice field two values", FieldsSetValues: []FieldSetValues{{SetValues: []string{"int-slice-field=6", "int-slice-field=66"}, FieldName: "IntSliceField", FieldValue: []int{6, 66}}}},
+		{Name: "bool slice field two values", FieldsSetValues: []FieldSetValues{{SetValues: []string{"bool-slice-field=true", "bool-slice-field=false"}, FieldName: "BoolSliceField", FieldValue: []bool{true, false}}}},
+		{Name: "uint slice field two values", FieldsSetValues: []FieldSetValues{{SetValues: []string{"uint-slice-field=6", "uint-slice-field=66"}, FieldName: "UintSliceField", FieldValue: []uint{uint(6), uint(66)}}}},
+		{Name: "four two values fields combined", FieldsSetValues: []FieldSetValues{
 			{SetValues: []string{"string-slice-field=test", "string-slice-field=test2"}, FieldName: "StringSliceField", FieldValue: []string{"test", "test2"}},
 			{SetValues: []string{"int-slice-field=6", "int-slice-field=66"}, FieldName: "IntSliceField", FieldValue: []int{6, 66}},
 			{SetValues: []string{"bool-slice-field=true", "bool-slice-field=false"}, FieldName: "BoolSliceField", FieldValue: []bool{true, false}},
 			{SetValues: []string{"uint-slice-field=6", "uint-slice-field=66"}, FieldName: "UintSliceField", FieldValue: []uint{uint(6), uint(66)}},
-		},
+		}},
 	}
 
 	for _, test := range tests {
-		configMock := ConfigMock{}
-		configMockElemValue := reflect.ValueOf(&configMock).Elem()
+		t.Run(test.Name, func(t *testing.T) {
+			configMock := ConfigMock{}
+			configMockElemValue := reflect.ValueOf(&configMock).Elem()
 
-		var setValues []string
-		for _, setValueInfo := range test {
-			for _, setValue := range setValueInfo.SetValues {
-				setValues = append(setValues, setValue)
+			var setValues []string
+			for _, fieldSetValues := range test.FieldsSetValues {
+				setValues = append(setValues, fieldSetValues.SetValues...)
 			}
-		}
 
-		err := mergeSetFlag(configMockElemValue, setValues)
+			err := mergeSetFlag(configMockElemValue, setValues)
 
-		if err != nil {
-			t.Errorf("unexpected error result - err: %v", err)
-			continue
-		}
-
-		for _, setValueInfo := range test {
-			fieldValue := configMockElemValue.FieldByName(setValueInfo.FieldName).Interface()
-			if !reflect.DeepEqual(fieldValue, setValueInfo.FieldValue) {
-				t.Errorf("unexpected result - expected: %v, actual: %v", setValueInfo.FieldValue, fieldValue)
+			if err != nil {
+				t.Errorf("unexpected error result - err: %v", err)
+				return
 			}
-		}
+
+			for _, fieldSetValues := range test.FieldsSetValues {
+				fieldValue := configMockElemValue.FieldByName(fieldSetValues.FieldName).Interface()
+				if !reflect.DeepEqual(fieldValue, fieldSetValues.FieldValue) {
+					t.Errorf("unexpected result - expected: %v, actual: %v", fieldSetValues.FieldValue, fieldValue)
+				}
+			}
+		})
 	}
 }
 
 func TestMergeSetFlagMixValues(t *testing.T) {
-	tests := [][]struct {
-		SetValues  []string
-		FieldName  string
-		FieldValue interface{}
+	tests := []struct {
+		Name            string
+		FieldsSetValues []FieldSetValues
 	}{
-		{
+		{Name: "single value all fields", FieldsSetValues: []FieldSetValues{
 			{SetValues: []string{"string-slice-field=test"}, FieldName: "StringSliceField", FieldValue: []string{"test"}},
 			{SetValues: []string{"int-slice-field=6"}, FieldName: "IntSliceField", FieldValue: []int{6}},
 			{SetValues: []string{"bool-slice-field=true"}, FieldName: "BoolSliceField", FieldValue: []bool{true}},
@@ -210,8 +251,8 @@ func TestMergeSetFlagMixValues(t *testing.T) {
 			{SetValues: []string{"int-field=6"}, FieldName: "IntField", FieldValue: 6},
 			{SetValues: []string{"bool-field=true"}, FieldName: "BoolField", FieldValue: true},
 			{SetValues: []string{"uint-field=6"}, FieldName: "UintField", FieldValue: uint(6)},
-		},
-		{
+		}},
+		{Name: "two values slice fields and single value fields", FieldsSetValues: []FieldSetValues{
 			{SetValues: []string{"string-slice-field=test", "string-slice-field=test2"}, FieldName: "StringSliceField", FieldValue: []string{"test", "test2"}},
 			{SetValues: []string{"int-slice-field=6", "int-slice-field=66"}, FieldName: "IntSliceField", FieldValue: []int{6, 66}},
 			{SetValues: []string{"bool-slice-field=true", "bool-slice-field=false"}, FieldName: "BoolSliceField", FieldValue: []bool{true, false}},
@@ -220,33 +261,33 @@ func TestMergeSetFlagMixValues(t *testing.T) {
 			{SetValues: []string{"int-field=6"}, FieldName: "IntField", FieldValue: 6},
 			{SetValues: []string{"bool-field=true"}, FieldName: "BoolField", FieldValue: true},
 			{SetValues: []string{"uint-field=6"}, FieldName: "UintField", FieldValue: uint(6)},
-		},
+		}},
 	}
 
 	for _, test := range tests {
-		configMock := ConfigMock{}
-		configMockElemValue := reflect.ValueOf(&configMock).Elem()
+		t.Run(test.Name, func(t *testing.T) {
+			configMock := ConfigMock{}
+			configMockElemValue := reflect.ValueOf(&configMock).Elem()
 
-		var setValues []string
-		for _, setValueInfo := range test {
-			for _, setValue := range setValueInfo.SetValues {
-				setValues = append(setValues, setValue)
+			var setValues []string
+			for _, fieldSetValues := range test.FieldsSetValues {
+				setValues = append(setValues, fieldSetValues.SetValues...)
 			}
-		}
 
-		err := mergeSetFlag(configMockElemValue, setValues)
+			err := mergeSetFlag(configMockElemValue, setValues)
 
-		if err != nil {
-			t.Errorf("unexpected error result - err: %v", err)
-			continue
-		}
-
-		for _, setValueInfo := range test {
-			fieldValue := configMockElemValue.FieldByName(setValueInfo.FieldName).Interface()
-			if !reflect.DeepEqual(fieldValue, setValueInfo.FieldValue) {
-				t.Errorf("unexpected result - expected: %v, actual: %v", setValueInfo.FieldValue, fieldValue)
+			if err != nil {
+				t.Errorf("unexpected error result - err: %v", err)
+				return
 			}
-		}
+
+			for _, fieldSetValues := range test.FieldsSetValues {
+				fieldValue := configMockElemValue.FieldByName(fieldSetValues.FieldName).Interface()
+				if !reflect.DeepEqual(fieldValue, fieldSetValues.FieldValue) {
+					t.Errorf("unexpected result - expected: %v, actual: %v", fieldSetValues.FieldValue, fieldValue)
+				}
+			}
+		})
 	}
 }
 
@@ -283,16 +324,18 @@ func TestGetParsedValueValidValue(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		parsedValue, err := getParsedValue(test.Kind, test.StringValue)
+		t.Run(fmt.Sprintf("%v %v", test.Kind, test.StringValue), func(t *testing.T) {
+			parsedValue, err := getParsedValue(test.Kind, test.StringValue)
 
-		if err != nil {
-			t.Errorf("unexpected error result - err: %v", err)
-			continue
-		}
+			if err != nil {
+				t.Errorf("unexpected error result - err: %v", err)
+				return
+			}
 
-		if parsedValue.Interface() != test.ActualValue {
-			t.Errorf("unexpected result - expected: %v, actual: %v", test.ActualValue, parsedValue)
-		}
+			if parsedValue.Interface() != test.ActualValue {
+				t.Errorf("unexpected result - expected: %v, actual: %v", test.ActualValue, parsedValue)
+			}
+		})
 	}
 }
 
@@ -326,15 +369,17 @@ func TestGetParsedValueInvalidValue(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		parsedValue, err := getParsedValue(test.Kind, test.StringValue)
+		t.Run(fmt.Sprintf("%v %v", test.Kind, test.StringValue), func(t *testing.T) {
+			parsedValue, err := getParsedValue(test.Kind, test.StringValue)
 
-		if err == nil {
-			t.Errorf("unexpected unhandled error - stringValue: %v, Kind: %v", test.StringValue, test.Kind)
-			continue
-		}
+			if err == nil {
+				t.Errorf("unexpected unhandled error - stringValue: %v, Kind: %v", test.StringValue, test.Kind)
+				return
+			}
 
-		if parsedValue != reflect.ValueOf(nil) {
-			t.Errorf("unexpected parsed value - parsedValue: %v", parsedValue)
-		}
+			if parsedValue != reflect.ValueOf(nil) {
+				t.Errorf("unexpected parsed value - parsedValue: %v", parsedValue)
+			}
+		})
 	}
 }

cli/config/config_test.go

@@ -15,9 +15,11 @@ func TestConfigWriteIgnoresReadonlyFields(t *testing.T) {
 
 	configWithDefaults, _ := config.GetConfigWithDefaults()
 	for _, readonlyField := range readonlyFields {
-		if strings.Contains(configWithDefaults, readonlyField) {
-			t.Errorf("unexpected result - readonly field: %v, config: %v", readonlyField, configWithDefaults)
-		}
+		t.Run(readonlyField, func(t *testing.T) {
+			if strings.Contains(configWithDefaults, readonlyField) {
+				t.Errorf("unexpected result - readonly field: %v, config: %v", readonlyField, configWithDefaults)
+			}
+		})
 	}
 }
 

cli/mizu/sliceUtils_test.go

@@ -7,76 +7,84 @@ import (
 
 func TestContainsExists(t *testing.T) {
 	tests := []struct {
-		slice         []string
-		containsValue string
-		expected      bool
+		Slice         []string
+		ContainsValue string
+		Expected      bool
 	}{
-		{slice: []string{"apple", "orange", "banana", "grapes"}, containsValue: "apple", expected: true},
-		{slice: []string{"apple", "orange", "banana", "grapes"}, containsValue: "orange", expected: true},
-		{slice: []string{"apple", "orange", "banana", "grapes"}, containsValue: "banana", expected: true},
-		{slice: []string{"apple", "orange", "banana", "grapes"}, containsValue: "grapes", expected: true},
+		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "apple", Expected: true},
+		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "orange", Expected: true},
+		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "banana", Expected: true},
+		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "grapes", Expected: true},
 	}
 
 	for _, test := range tests {
-		actual := mizu.Contains(test.slice, test.containsValue)
-		if actual != test.expected {
-			t.Errorf("unexpected result - expected: %v, actual: %v", test.expected, actual)
-		}
+		t.Run(test.ContainsValue, func(t *testing.T) {
+			actual := mizu.Contains(test.Slice, test.ContainsValue)
+			if actual != test.Expected {
+				t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
+			}
+		})
 	}
 }
 
 func TestContainsNotExists(t *testing.T) {
 	tests := []struct {
-		slice         []string
-		containsValue string
-		expected      bool
+		Slice         []string
+		ContainsValue string
+		Expected      bool
 	}{
-		{slice: []string{"apple", "orange", "banana", "grapes"}, containsValue: "cat", expected: false},
-		{slice: []string{"apple", "orange", "banana", "grapes"}, containsValue: "dog", expected: false},
-		{slice: []string{"apple", "orange", "banana", "grapes"}, containsValue: "apples", expected: false},
-		{slice: []string{"apple", "orange", "banana", "grapes"}, containsValue: "rapes", expected: false},
+		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "cat", Expected: false},
+		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "dog", Expected: false},
+		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "apples", Expected: false},
+		{Slice: []string{"apple", "orange", "banana", "grapes"}, ContainsValue: "rapes", Expected: false},
 	}
 
 	for _, test := range tests {
-		actual := mizu.Contains(test.slice, test.containsValue)
-		if actual != test.expected {
-			t.Errorf("unexpected result - expected: %v, actual: %v", test.expected, actual)
-		}
+		t.Run(test.ContainsValue, func(t *testing.T) {
+			actual := mizu.Contains(test.Slice, test.ContainsValue)
+			if actual != test.Expected {
+				t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
+			}
+		})
 	}
 }
 
 func TestContainsEmptySlice(t *testing.T) {
 	tests := []struct {
-		slice         []string
-		containsValue string
-		expected      bool
+		Slice         []string
+		ContainsValue string
+		Expected      bool
 	}{
-		{slice: []string{}, containsValue: "cat", expected: false},
-		{slice: []string{}, containsValue: "dog", expected: false},
+		{Slice: []string{}, ContainsValue: "cat", Expected: false},
+		{Slice: []string{}, ContainsValue: "dog", Expected: false},
 	}
 
 	for _, test := range tests {
-		actual := mizu.Contains(test.slice, test.containsValue)
-		if actual != test.expected {
-			t.Errorf("unexpected result - expected: %v, actual: %v", test.expected, actual)
-		}
+		t.Run(test.ContainsValue, func(t *testing.T) {
+			actual := mizu.Contains(test.Slice, test.ContainsValue)
+			if actual != test.Expected {
+				t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
+			}
+		})
 	}
 }
 
 func TestContainsNilSlice(t *testing.T) {
 	tests := []struct {
-		slice         []string
-		containsValue string
-		expected      bool
+		Slice         []string
+		ContainsValue string
+		Expected      bool
 	}{
-		{slice: nil, containsValue: "cat", expected: false},
-		{slice: nil, containsValue: "dog", expected: false},
+		{Slice: nil, ContainsValue: "cat", Expected: false},
+		{Slice: nil, ContainsValue: "dog", Expected: false},
 	}
 
 	for _, test := range tests {
-		actual := mizu.Contains(test.slice, test.containsValue)
-		if actual != test.expected {
-			t.Errorf("unexpected result - expected: %v, actual: %v", test.expected, actual)
-		}
+		t.Run(test.ContainsValue, func(t *testing.T) {
+			actual := mizu.Contains(test.Slice, test.ContainsValue)
+			if actual != test.Expected {
+				t.Errorf("unexpected result - Expected: %v, actual: %v", test.Expected, actual)
+			}
+		})
 	}
 }

codecov.yml

@@ -0,0 +1,8 @@
+coverage:
+  status:
+    project:
+      default:
+        threshold: 1%
+    patch:
+      default:
+        enabled: no

tap/http_reader.go

@@ -79,6 +79,7 @@ func (h *httpReader) Read(p []byte) (int, error) {
 			clientHello := tlsx.ClientHello{}
 			err := clientHello.Unmarshall(msg.bytes)
 			if err == nil {
+				statsTracker.incTlsConnectionsCount()
 				fmt.Printf("Detected TLS client hello with SNI %s\n", clientHello.SNI)
 				numericPort, _ := strconv.Atoi(h.tcpID.dstPort)
 				h.outboundLinkWriter.WriteOutboundLink(h.tcpID.srcIP, h.tcpID.dstIP, numericPort, clientHello.SNI, TLSProtocol)
@@ -176,7 +177,7 @@ func (h *httpReader) handleHTTP2Stream() error {
 	}
 
 	if reqResPair != nil {
-		statsTracker.incMatchedMessages()
+		statsTracker.incMatchedPairs()
 
 		if h.harWriter != nil {
 			h.harWriter.WritePair(
@@ -215,7 +216,7 @@ func (h *httpReader) handleHTTP1ClientStream(b *bufio.Reader) error {
 	ident := fmt.Sprintf("%s->%s %s->%s %d", h.tcpID.srcIP, h.tcpID.dstIP, h.tcpID.srcPort, h.tcpID.dstPort, h.messageCount)
 	reqResPair := reqResMatcher.registerRequest(ident, req, h.captureTime)
 	if reqResPair != nil {
-		statsTracker.incMatchedMessages()
+		statsTracker.incMatchedPairs()
 
 		if h.harWriter != nil {
 			h.harWriter.WritePair(
@@ -281,7 +282,7 @@ func (h *httpReader) handleHTTP1ServerStream(b *bufio.Reader) error {
 	ident := fmt.Sprintf("%s->%s %s->%s %d", h.tcpID.dstIP, h.tcpID.srcIP, h.tcpID.dstPort, h.tcpID.srcPort, h.messageCount)
 	reqResPair := reqResMatcher.registerResponse(ident, res, h.captureTime)
 	if reqResPair != nil {
-		statsTracker.incMatchedMessages()
+		statsTracker.incMatchedPairs()
 
 		if h.harWriter != nil {
 			h.harWriter.WritePair(

tap/passive_tapper.go

@@ -10,9 +10,9 @@ package tap
 
 import (
 	"encoding/hex"
+	"encoding/json"
 	"flag"
 	"fmt"
-	"github.com/romana/rlog"
 	"log"
 	"os"
 	"os/signal"
@@ -23,6 +23,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/romana/rlog"
+
 	"github.com/google/gopacket"
 	"github.com/google/gopacket/examples/util"
 	"github.com/google/gopacket/ip4defrag"
@@ -374,9 +376,7 @@ func startPassiveTapper(harWriter *HarWriter, outboundLinkWriter *OutboundLinkWr
 			errorMapLen := len(errorsMap)
 			errorsSummery := fmt.Sprintf("%v", errorsMap)
 			errorsMapMutex.Unlock()
-			log.Printf("Processed %v packets (%v bytes) in %v (errors: %v, errTypes:%v) - Errors Summary: %s",
-				statsTracker.appStats.TotalPacketsCount,
-				statsTracker.appStats.TotalProcessedBytes,
+			log.Printf("%v (errors: %v, errTypes:%v) - Errors Summary: %s",
 				time.Since(statsTracker.appStats.StartTime),
 				nErrors,
 				errorMapLen,
@@ -395,14 +395,15 @@ func startPassiveTapper(harWriter *HarWriter, outboundLinkWriter *OutboundLinkWr
 
 			// Since the last print
 			cleanStats := cleaner.dumpStats()
-			matchedMessages := statsTracker.dumpStats()
 			log.Printf(
-				"flushed connections %d, closed connections: %d, deleted messages: %d, matched messages: %d",
+				"cleaner - flushed connections: %d, closed connections: %d, deleted messages: %d",
 				cleanStats.flushed,
 				cleanStats.closed,
 				cleanStats.deleted,
-				matchedMessages,
 			)
+			currentAppStats := statsTracker.dumpStats()
+			appStatsJSON, _ := json.Marshal(currentAppStats)
+			log.Printf("app stats - %v", string(appStatsJSON))
 		}
 	}()
 
@@ -414,7 +415,7 @@ func startPassiveTapper(harWriter *HarWriter, outboundLinkWriter *OutboundLinkWr
 		packetsCount := statsTracker.incPacketsCount()
 		rlog.Debugf("PACKET #%d", packetsCount)
 		data := packet.Data()
-		statsTracker.updateProcessedSize(int64(len(data)))
+		statsTracker.updateProcessedBytes(int64(len(data)))
 		if *hexdumppkt {
 			rlog.Debugf("Packet content (%d/0x%x) - %s", len(data), len(data), hex.Dump(data))
 		}
@@ -448,6 +449,7 @@ func startPassiveTapper(harWriter *HarWriter, outboundLinkWriter *OutboundLinkWr
 
 		tcp := packet.Layer(layers.LayerTypeTCP)
 		if tcp != nil {
+			statsTracker.incTcpPacketsCount()
 			tcp := tcp.(*layers.TCP)
 			if *checksum {
 				err := tcp.SetNetworkLayerForChecksum(packet.NetworkLayer())
@@ -465,14 +467,14 @@ func startPassiveTapper(harWriter *HarWriter, outboundLinkWriter *OutboundLinkWr
 			assemblerMutex.Unlock()
 		}
 
-		done := *maxcount > 0 && statsTracker.appStats.TotalPacketsCount >= *maxcount
+		done := *maxcount > 0 && statsTracker.appStats.PacketsCount >= *maxcount
 		if done {
 			errorsMapMutex.Lock()
 			errorMapLen := len(errorsMap)
 			errorsMapMutex.Unlock()
 			log.Printf("Processed %v packets (%v bytes) in %v (errors: %v, errTypes:%v)",
-				statsTracker.appStats.TotalPacketsCount,
-				statsTracker.appStats.TotalProcessedBytes,
+				statsTracker.appStats.PacketsCount,
+				statsTracker.appStats.ProcessedBytes,
 				time.Since(statsTracker.appStats.StartTime),
 				nErrors,
 				errorMapLen)

tap/stats_tracker.go

@@ -6,50 +6,99 @@ import (
 )
 
 type AppStats struct {
-	StartTime            time.Time `json:"startTime"`
-	MatchedMessages      int       `json:"matchedMessages"`
-	TotalPacketsCount    int64     `json:"totalPacketsCount"`
-	TotalProcessedBytes  int64     `json:"totalProcessedBytes"`
-	TotalMatchedMessages int64     `json:"totalMatchedMessages"`
+	StartTime                   time.Time `json:"-"`
+	ProcessedBytes              int64     `json:"processedBytes"`
+	PacketsCount                int64     `json:"packetsCount"`
+	TcpPacketsCount             int64     `json:"tcpPacketsCount"`
+	ReassembledTcpPayloadsCount int64     `json:"reassembledTcpPayloadsCount"`
+	TlsConnectionsCount         int64     `json:"tlsConnectionsCount"`
+	MatchedPairs                int64     `json:"matchedPairs"`
 }
 
 type StatsTracker struct {
-	appStats                AppStats
-	matchedMessagesMutex    sync.Mutex
-	totalPacketsCountMutex  sync.Mutex
-	totalProcessedSizeMutex sync.Mutex
+	appStats                         AppStats
+	processedBytesMutex              sync.Mutex
+	packetsCountMutex                sync.Mutex
+	tcpPacketsCountMutex             sync.Mutex
+	reassembledTcpPayloadsCountMutex sync.Mutex
+	tlsConnectionsCountMutex         sync.Mutex
+	matchedPairsMutex                sync.Mutex
 }
 
-func (st *StatsTracker) incMatchedMessages() {
-	st.matchedMessagesMutex.Lock()
-	st.appStats.MatchedMessages++
-	st.appStats.TotalMatchedMessages++
-	st.matchedMessagesMutex.Unlock()
+func (st *StatsTracker) incMatchedPairs() {
+	st.matchedPairsMutex.Lock()
+	st.appStats.MatchedPairs++
+	st.matchedPairsMutex.Unlock()
 }
 
 func (st *StatsTracker) incPacketsCount() int64 {
-	st.totalPacketsCountMutex.Lock()
-	st.appStats.TotalPacketsCount++
-	currentPacketsCount := st.appStats.TotalPacketsCount
-	st.totalPacketsCountMutex.Unlock()
+	st.packetsCountMutex.Lock()
+	st.appStats.PacketsCount++
+	currentPacketsCount := st.appStats.PacketsCount
+	st.packetsCountMutex.Unlock()
 	return currentPacketsCount
 }
 
-func (st *StatsTracker) updateProcessedSize(size int64) {
-	st.totalProcessedSizeMutex.Lock()
-	st.appStats.TotalProcessedBytes += size
-	st.totalProcessedSizeMutex.Unlock()
+func (st *StatsTracker) incTcpPacketsCount() {
+	st.tcpPacketsCountMutex.Lock()
+	st.appStats.TcpPacketsCount++
+	st.tcpPacketsCountMutex.Unlock()
+}
+
+func (st *StatsTracker) incReassembledTcpPayloadsCount() {
+	st.reassembledTcpPayloadsCountMutex.Lock()
+	st.appStats.ReassembledTcpPayloadsCount++
+	st.reassembledTcpPayloadsCountMutex.Unlock()
+}
+
+func (st *StatsTracker) incTlsConnectionsCount() {
+	st.tlsConnectionsCountMutex.Lock()
+	st.appStats.TlsConnectionsCount++
+	st.tlsConnectionsCountMutex.Unlock()
+}
+
+func (st *StatsTracker) updateProcessedBytes(size int64) {
+	st.processedBytesMutex.Lock()
+	st.appStats.ProcessedBytes += size
+	st.processedBytesMutex.Unlock()
 }
 
 func (st *StatsTracker) setStartTime(startTime time.Time) {
 	st.appStats.StartTime = startTime
 }
 
-func (st *StatsTracker) dumpStats() int {
-	st.matchedMessagesMutex.Lock()
-	matchedMessages := st.appStats.MatchedMessages
-	st.appStats.MatchedMessages = 0
-	st.matchedMessagesMutex.Unlock()
+func (st *StatsTracker) dumpStats() *AppStats {
+	currentAppStats := &AppStats{StartTime: st.appStats.StartTime}
 
-	return matchedMessages
+	st.processedBytesMutex.Lock()
+	currentAppStats.ProcessedBytes = st.appStats.ProcessedBytes
+	st.appStats.ProcessedBytes = 0
+	st.processedBytesMutex.Unlock()
+
+	st.packetsCountMutex.Lock()
+	currentAppStats.PacketsCount = st.appStats.PacketsCount
+	st.appStats.PacketsCount = 0
+	st.packetsCountMutex.Unlock()
+
+	st.tcpPacketsCountMutex.Lock()
+	currentAppStats.TcpPacketsCount = st.appStats.TcpPacketsCount
+	st.appStats.TcpPacketsCount = 0
+	st.tcpPacketsCountMutex.Unlock()
+
+	st.reassembledTcpPayloadsCountMutex.Lock()
+	currentAppStats.ReassembledTcpPayloadsCount = st.appStats.ReassembledTcpPayloadsCount
+	st.appStats.ReassembledTcpPayloadsCount = 0
+	st.reassembledTcpPayloadsCountMutex.Unlock()
+
+	st.tlsConnectionsCountMutex.Lock()
+	currentAppStats.TlsConnectionsCount = st.appStats.TlsConnectionsCount
+	st.appStats.TlsConnectionsCount = 0
+	st.tlsConnectionsCountMutex.Unlock()
+
+	st.matchedPairsMutex.Lock()
+	currentAppStats.MatchedPairs = st.appStats.MatchedPairs
+	st.appStats.MatchedPairs = 0
+	st.matchedPairsMutex.Unlock()
+
+	return currentAppStats
 }

tap/tcp_stream.go

@@ -148,6 +148,7 @@ func (t *tcpStream) ReassembledSG(sg reassembly.ScatterGather, ac reassembly.Ass
 			}
 			// This is where we pass the reassembled information onwards
 			// This channel is read by an httpReader object
+			statsTracker.incReassembledTcpPayloadsCount()
 			if dir == reassembly.TCPDirClientToServer && !t.reversed {
 				t.client.msgQueue <- httpReaderDataMsg{data, ac.GetCaptureInfo().Timestamp}
 			} else {