Linters fix

.revive.toml

@@ -29,7 +29,7 @@
     [rule.indent-error-flow]
     [rule.errorf]
     [rule.argument-limit]
-      arguments =[4]
+      arguments =[5]
 
     [rule.atomic]
     [rule.bare-return]

cmd/logs-converter-cli/main.go

@@ -26,7 +26,13 @@ func main() {
 		log.Fatalf("Failed to load config: %v \nExiting", errLoadCfg)
 	}
 
-	dbc, err := db.Connect(db.StorageTypeMongo, cfg.DBURL, cfg.DBName, cfg.MongoCollection, cfg.DBUsername, cfg.DBPassword)
+	dbc, err := db.Connect(db.StorageTypeMongo, db.Params{
+		URL:        cfg.DBURL,
+		DB:         cfg.DBName,
+		Collection: cfg.MongoCollection,
+		Username:   cfg.DBUsername,
+		Password:   cfg.DBPassword,
+	})
 	if err != nil {
 		log.Fatalf("failed to connect to database: %v", err)
 	}
@@ -52,16 +58,24 @@ func main() {
 		stop <- struct{}{}
 	}()
 
-	var storedModelsCnt, failedToStoreCnt, totalRecCnt uint64
+	process(dbc, resChan, signals, errorsChan, stop)
+}
+
+func process(dbc db.Repository, resChan <-chan *models.LogModel, signals <-chan os.Signal,
+	errorsChan <-chan error, stopChan <-chan struct{}) {
+	var (
+		storedModelsCnt, failedToStoreCnt, totalRecCnt uint64
+	)
+
+	defer func() {
+		dbc.Close()
+		executionSummary(totalRecCnt, storedModelsCnt, failedToStoreCnt)
+	}()
 
 	for {
 		select {
 		case <-signals:
 			log.Infof("Got UNIX signal, shutting down")
-			dbc.Close()
-			close(resChan)
-			executionSummary(totalRecCnt, storedModelsCnt, failedToStoreCnt)
-
 			return
 		case data := <-resChan:
 			totalRecCnt++
@@ -77,19 +91,16 @@ func main() {
 				storedModelsCnt++
 				log.Infof("Current amount of stored models: %d", storedModelsCnt)
 			}
-		case errors := <-errorsChan:
-			log.Errorf("Receive error: %v", errors)
-		case <-stop:
+		case err := <-errorsChan:
+			if err != nil {
+				log.Errorf("Receive error: %v", err)
+			}
+		case <-stopChan:
 			log.Printf("stop received")
-			close(resChan)
-			dbc.Close()
-			executionSummary(totalRecCnt, storedModelsCnt, failedToStoreCnt)
-
 			return
 		}
 	}
 }
-
 func startJobs(files map[string]string, filesmustExist bool, followFiles bool, wg *sync.WaitGroup,
 	resChan chan *models.LogModel, errorsChan chan error) {
 	for l, format := range files {
@@ -107,10 +118,10 @@ func executionSummary(received uint64, stored uint64, failed uint64) {
 		"Total models received\tStored in DBName\tFailed to store in DBName\n"+
 		"%d\t%d\t%d", received, stored, failed)
 	if err != nil {
-		log.Fatalf("failed to print execution summary: %v", err)
+		log.Errorf("failed to print execution summary: %v", err)
 	}
 
 	if err := w.Flush(); err != nil {
-		log.Fatalf("failed to flush statistic writer: %v", err)
+		log.Errorf("failed to flush statistic writer: %v", err)
 	}
 }

internal/config/config.go

@@ -1,3 +1,4 @@
+// Package config provide configuration.
 package config
 
 import (

internal/config/config_test.go

@@ -8,33 +8,50 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestLoadConfig(t *testing.T) {
+type expectedResult struct {
+	wantConfig *Config
+	wantErr    bool
+}
+
+type test struct {
+	id             int
+	description    string
+	inputFile      string
+	expectedResult expectedResult
+}
 
-	type expectedResult struct {
-		wantConfig *Config
-		wantErr    bool
+func TestLoadConfig(t *testing.T) {
+	for _, tc := range tests() {
+		tc := tc
+		t.Run(fmt.Sprintf("Test%d:%s", tc.id, tc.description), func(t *testing.T) {
+			gotModel, err := LoadConfig(tc.inputFile)
+			if tc.expectedResult.wantErr {
+				assert.Error(t, err)
+				return
+			}
+			assert.NoError(t, err)
+			assert.Equal(t, tc.expectedResult.wantConfig, gotModel)
+		})
 	}
+}
 
-	var tests = []struct {
-		id             int
-		description    string
-		inputFile      string
-		expectedResult expectedResult
-	}{
+func tests() []test {
+	return []test{
 		{
 			id:          1,
 			description: `Check configuration loading from cofig file`,
 			inputFile:   filepath.Join("testdata", "valid-config.toml"),
 			expectedResult: expectedResult{
 				wantConfig: &Config{
-					LogsFilesListJSON: `{"testdata/testfile1.log":"second_format","testdata/dir1/testfile2.log":"first_format"}`,
-					LogLevel:          "Info",
-					DBURL:             "localhost:27017",
-					DBUsername:        "",
-					DBPassword:        "",
-					DBName:            "myDB",
-					MongoCollection:   "logs",
-					DropDB:            true,
+					LogsFilesListJSON: "{\"testdata/testfile1.log\":\"second_format\"," +
+						"\"testdata/dir1/testfile2.log\":\"first_format\"}",
+					LogLevel:        "Info",
+					DBURL:           "localhost:27017",
+					DBUsername:      "",
+					DBPassword:      "",
+					DBName:          "myDB",
+					MongoCollection: "logs",
+					DropDB:          true,
 					logsFilesList: map[string]string{"testdata/testfile1.log": "second_format",
 						"testdata/dir1/testfile2.log": "first_format"},
 					FilesMustExist: true,
@@ -62,17 +79,4 @@ func TestLoadConfig(t *testing.T) {
 			},
 		},
 	}
-
-	for _, tc := range tests {
-		tc := tc
-		t.Run(fmt.Sprintf("Test%d:%s", tc.id, tc.description), func(t *testing.T) {
-			gotModel, err := LoadConfig(tc.inputFile)
-			if tc.expectedResult.wantErr {
-				assert.Error(t, err)
-				return
-			}
-			assert.NoError(t, err)
-			assert.Equal(t, tc.expectedResult.wantConfig, gotModel)
-		})
-	}
 }

internal/converter/constants.go

@@ -1,3 +1,4 @@
+// Package converter provides functionality for processing logs.
 package converter
 
 // Constants for format detector

internal/converter/converter.go

@@ -1,3 +1,4 @@
+// Package converter provides functionality for processing logs.
 package converter
 
 import (
@@ -63,12 +64,10 @@ func processLine(logName string, line string, format string, lineNumber uint64)
 		return nil, err
 	}
 
-	var msg string
+	msg := lineElements[1]
 	// For case when log message contain additional " | " to not miss other part of message
 	if len(lineElements) > 2 {
 		msg = strings.Join(lineElements[1:], " | ")
-	} else {
-		msg = lineElements[1]
 	}
 
 	md := &models.LogModel{
@@ -83,25 +82,22 @@ func processLine(logName string, line string, format string, lineNumber uint64)
 
 // parseTime parses logTime string as format that was passed and return time.Time representation of it
 func parseTime(logTimeStr string, format string) (time.Time, error) {
+	var layout string
+
 	switch format {
 	case firstFormat:
-		logTime, errParse := time.Parse(firstFormatLayout, logTimeStr)
-		if errParse != nil {
-			log.Errorf("parseTime: failed to parse logTime [%s] as format [%s]: %v", logTimeStr, format, errParse)
-			return time.Time{}, fmt.Errorf("failed to parse logTime [%s] as format [%s]: %v", logTimeStr, format, errParse)
-		}
-
-		return logTime, nil
+		layout = firstFormatLayout
 	case secondFormat:
-		logTime, errParse := time.Parse(secondFormatLayout, logTimeStr)
-		if errParse != nil {
-			log.Errorf("parseTime: failed to parse logTime [%s] as format [%s]: %v", logTimeStr, format, errParse)
-			return time.Time{}, fmt.Errorf("failed to parse logTime [%s] as format [%s]: %v", logTimeStr, format, errParse)
-		}
-
-		return logTime, nil
+		layout = secondFormatLayout
 	default:
-		log.Errorf("parseTime: unexpected time format received (%s)", logTimeStr)
-		return time.Time{}, fmt.Errorf("unexpected time format received (%s)", logTimeStr)
+		return time.Time{}, errors.Errorf("unexpected time format received (%s)", logTimeStr)
 	}
+
+	logTime, err := time.Parse(layout, logTimeStr)
+	if err != nil {
+		return time.Time{}, errors.Wrapf(err, "failed to parse logTime [%s] as format [%s]",
+			logTimeStr, format)
+	}
+
+	return logTime, nil
 }