feat: add optional output to log file

use an env variable or a cli flag to enable it

Author: BoxBoxJason

README.md

@@ -65,6 +65,7 @@ If mandatory arguments are not provided, the program will prompt for them.
 | `--destination-big` | `DESTINATION_GITLAB_BIG` | No | Specify if the destination GitLab instance is a big instance (default: false) |
 | `--mirror-mapping` | `MIRROR_MAPPING` | Yes | Path to a JSON file containing the mirror mapping |
 | `--retry` or `-r` | N/A | No | Number of retries for failed GitLab API requests (default: 3) |
+| `--log-file` |  `GITLAB_SYNC_LOG_FILE` | No | Path to a log file for output logs (default: `none`, only outputs logs to stderr) |
 
 ## Example
 

cmd/main.go

@@ -23,6 +23,7 @@ func main() {
 	var args utils.ParserArgs
 	var mirrorMappingPath string
 	var timeout int
+	var logFile string
 
 	var rootCmd = &cobra.Command{
 		Use:     "gitlab-sync",
@@ -31,7 +32,7 @@ func main() {
 		Long:    "Fully customizable gitlab repositories and groups mirroring between two (or one) gitlab instances.",
 		Run: func(cmd *cobra.Command, cmdArgs []string) {
 			// Set up the logger
-			setupZapLogger(args.Verbose)
+			setupZapLogger(args.Verbose, strings.TrimSpace(logFile))
 			zap.L().Debug("Verbose mode enabled")
 			zap.L().Debug("Parsing command line arguments")
 
@@ -90,6 +91,7 @@ func main() {
 	rootCmd.Flags().BoolVar(&args.DryRun, "dry-run", false, "Perform a dry run without making any changes")
 	rootCmd.Flags().IntVarP(&timeout, "timeout", "t", 30, "Timeout in seconds for GitLab API requests")
 	rootCmd.Flags().IntVarP(&args.Retry, "retry", "r", 3, "Number of retries for failed requests")
+	rootCmd.Flags().StringVar(&logFile, "log-file", strings.TrimSpace(os.Getenv("GITLAB_SYNC_LOG_FILE")), "Path to the log file")
 
 	if err := rootCmd.Execute(); err != nil {
 		zap.L().Error(err.Error())
@@ -133,10 +135,11 @@ func promptForMandatoryInput(defaultValue string, prompt string, errorMsg string
 	return input
 }
 
-// setupZapLogger sets up the Zap logger with the specified verbosity level.
+// setupZapLogger sets up the Zap logger with the specified verbosity level and optional file output.
 // It configures the logger to use ISO8601 time format and capitalizes the log levels.
 // The logger is set to production mode by default, but can be configured for debug mode if verbose is true.
-func setupZapLogger(verbose bool) {
+// If filename is not empty, the logger's output is redirected to the specified file.
+func setupZapLogger(verbose bool, filename string) {
 	// Set up the logger configuration
 	config := zap.NewProductionConfig()
 	config.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
@@ -147,6 +150,15 @@ func setupZapLogger(verbose bool) {
 		config.Level.SetLevel(zapcore.InfoLevel)
 	}
 
+	// If a filename is specified, update the output path.
+	if filename != "" {
+		err := os.MkdirAll(filepath.Dir(filename), 0700)
+		if err != nil {
+			zap.L().Fatal("Failed to create log directory: " + err.Error())
+		}
+		config.OutputPaths = []string{filename, "stderr"}
+	}
+
 	// Create the logger
 	logger, err := config.Build()
 	if err != nil {

cmd/main_test.go

@@ -14,37 +14,87 @@ const (
 	RECEIVED_INPUT = "Received input"
 )
 
-// setupZapLogger is assumed to be defined in the same module.
-// If it is in a different package, import that package accordingly.
-
-func TestSetupZapLoggerVerbose(t *testing.T) {
-	// Set up the logger in verbose mode.
-	setupZapLogger(true)
-
-	// The global logger (zap.L()) should allow debug logs.
-	// Check that debug logs are enabled.
-	if !zap.L().Core().Enabled(zap.DebugLevel) {
-		t.Error("Expected debug level to be enabled in verbose mode but it is not")
-	}
-
-	// Optionally, check that Info level logs are enabled.
-	if !zap.L().Core().Enabled(zap.InfoLevel) {
-		t.Error("Expected info level to be enabled in verbose mode but it is not")
-	}
-}
-
-func TestSetupZapLoggerNonVerbose(t *testing.T) {
-	// Set up the logger in non-verbose (production) mode.
-	setupZapLogger(false)
-
-	// The global logger (zap.L()) should not allow debug logs.
-	if zap.L().Core().Enabled(zap.DebugLevel) {
-		t.Error("Expected debug level to be disabled in non-verbose mode but it is enabled")
+func TestSetupZapLogger(t *testing.T) {
+	// Define the test cases in a table-driven approach.
+	tests := []struct {
+		name             string
+		verbose          bool
+		filename         string
+		debugExpected    bool
+		infoExpected     bool
+		shouldCreateFile bool
+	}{
+		{
+			name:             "Verbose without file",
+			verbose:          true,
+			filename:         "",
+			debugExpected:    true,
+			infoExpected:     true,
+			shouldCreateFile: false,
+		},
+		{
+			name:             "Verbose with file",
+			verbose:          true,
+			filename:         "test_verbose.log",
+			debugExpected:    true,
+			infoExpected:     true,
+			shouldCreateFile: true,
+		},
+		{
+			name:             "Non-Verbose without file",
+			verbose:          false,
+			filename:         "",
+			debugExpected:    false,
+			infoExpected:     true,
+			shouldCreateFile: false,
+		},
+		{
+			name:             "Non-Verbose with file",
+			verbose:          false,
+			filename:         "test_nonverbose.log",
+			debugExpected:    false,
+			infoExpected:     true,
+			shouldCreateFile: true,
+		},
 	}
 
-	// Info level logs must remain enabled.
-	if !zap.L().Core().Enabled(zap.InfoLevel) {
-		t.Error("Expected info level to be enabled in non-verbose mode but it is not")
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			// Call the setup function with appropriate parameters.
+			setupZapLogger(tc.verbose, tc.filename)
+
+			// Check that the logger's log level for debug is set as expected.
+			if zap.L().Core().Enabled(zap.DebugLevel) != tc.debugExpected {
+				t.Errorf("For verbose=%v, expected DebugLevel enabled to be %v, got %v",
+					tc.verbose, tc.debugExpected, zap.L().Core().Enabled(zap.DebugLevel))
+			}
+
+			// Check that info level is always enabled.
+			if zap.L().Core().Enabled(zap.InfoLevel) != tc.infoExpected {
+				t.Errorf("Expected InfoLevel enabled to be %v, got %v",
+					tc.infoExpected, zap.L().Core().Enabled(zap.InfoLevel))
+			}
+
+			// If a filename is provided, verify that the file is created.
+			if tc.shouldCreateFile && tc.filename != "" {
+				// Write a log entry to ensure that the logger flushes its output.
+				zap.L().Info("test log entry")
+				// Flush any buffered log entries.
+				if err := zap.L().Sync(); err != nil {
+					// On Windows, Sync may return an error, so we don't fail the test solely on that.
+					t.Logf("Sync error (possibly expected on Windows): %v", err)
+				}
+
+				// Check if the file exists.
+				if _, err := os.Stat(tc.filename); os.IsNotExist(err) {
+					t.Errorf("Expected log file %s to be created, but it does not exist", tc.filename)
+				} else if err != nil {
+					t.Errorf("Error checking log file %s: %v", tc.filename, err)
+				}
+				// Cleanup: remove the test log file.
+				os.Remove(tc.filename)
+			}
+		})
 	}
 }