Improve logging

ffprobe.go

@@ -18,35 +18,40 @@ type FFProbeOutput struct {
 // runs ffprobe with the provided args and returns (stdout, stderr, error)
 func runFfprobe(args []string) ([]byte, []byte, error) {
 	ffprobe := "ffprobe"
-
+	log.Infoln(ffprobe, strings.Join(args, " "))
-	fmt.Println(ffprobe, strings.Join(args, " "))
 	cmd := exec.Command(ffprobe, args...)
 	var stdout bytes.Buffer
 	var stderr bytes.Buffer
 	cmd.Stdout = &stdout
 	cmd.Stderr = &stderr
 	err := cmd.Run()
+
 	if err != nil {
-		fmt.Println("ffprobe error:", err, stdout.String(), stderr.String())
+		log.Errorf("ffprobe error: %v", err)
 	}
+	log.Infoln("stdout:", stdout.String())
+	log.Infoln("stderr:", stderr.String())
 	return stdout.Bytes(), stderr.Bytes(), err
 }
 
 func getAudioFormat(filename string) (string, error) {
 	output, _, err := runFfprobe([]string{"-v", "quiet", "-print_format", "json", "-show_streams", filename})
 	if err != nil {
-		return "", fmt.Errorf("ffprobe execution failed: %v", err)
+		log.Errorln("ffprobe error:", err)
+		return "", err
 	}
 
 	var ffprobeOutput FFProbeOutput
 	err = json.Unmarshal(output, &ffprobeOutput)
 	if err != nil {
-		return "", fmt.Errorf("failed to parse ffprobe output: %v", err)
+		log.Errorln("failed to parse ffprobe output:", err)
+		return "", err
 	}
 
 	numStreams := len(ffprobeOutput.Streams)
 	if numStreams > 1 || numStreams <= 0 {
-		return "", fmt.Errorf("%d streams in ffprobe output", numStreams)
+		log.Error(numStreams, "streams in ffprobe output", numStreams)
+		return "", err
 	}
 
 	return ffprobeOutput.Streams[0].CodecName, nil
@@ -62,14 +67,14 @@ func getStreamBitrate(path string, stream int) (uint, error) {
 
 	stdout, _, err := runFfprobe(ffprobeArgs)
 	if err != nil {
-		fmt.Println("getAudioBitrate error:", err, string(stdout))
+		fmt.Println("ffprobe error:", err, string(stdout))
 		return 0, err
 	}
 	bitrateStr := strings.TrimSpace(string(stdout))
 
 	bitrate, err := strconv.ParseUint(bitrateStr, 10, 32)
 	if err != nil {
-		fmt.Println("getAudioBitrate error:", err)
+		fmt.Println("parse bitrate error:", err)
 		return 0, err
 	}
 	return uint(bitrate), nil
@@ -84,14 +89,14 @@ func getFormatBitrate(path string) (uint, error) {
 
 	stdout, _, err := runFfprobe(ffprobeArgs)
 	if err != nil {
-		fmt.Println("getFormatBitrate error:", err, string(stdout))
+		fmt.Println("ffprobe error:", err, string(stdout))
 		return 0, err
 	}
 	bitrateStr := strings.TrimSpace(string(stdout))
 
 	bitrate, err := strconv.ParseUint(bitrateStr, 10, 32)
 	if err != nil {
-		fmt.Println("getFormatBitrate error:", err)
+		fmt.Println("parse bitrate error:", err)
 		return 0, err
 	}
 	return uint(bitrate), nil

handlers.go

@@ -255,31 +255,18 @@ func getLength(path string) (float64, error) {
 
 func getVideoWidth(path string) (uint, error) {
 
-	ffprobe := "ffprobe"
+	stdout, _, err := runFfprobe([]string{"-v", "error", "-select_streams",
-	ffprobeArgs := []string{"-v", "error", "-select_streams",
 		"v:0", "-count_packets", "-show_entries",
-		"stream=width", "-of", "csv=p=0", path}
+		"stream=width", "-of", "csv=p=0", path})
 
-	fmt.Println(ffprobe, strings.Join(ffprobeArgs, " "))
-	cmd := exec.Command(ffprobe, ffprobeArgs...)
-
-	var stdout bytes.Buffer
-	var stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	err := cmd.Run()
 	if err != nil {
-		fmt.Println("getVideoWidth cmd error:", err)
+		log.Errorln("ffprobe error", err)
-		fmt.Println("stdout was")
-		fmt.Println(stdout)
-		fmt.Println("stderr was")
-		fmt.Println(stderr)
 		return 0, err
 	}
 
-	result, err := strconv.ParseUint(strings.TrimSpace(stdout.String()), 10, 32)
+	result, err := strconv.ParseUint(strings.TrimSpace(string(stdout)), 10, 32)
 	if err != nil {
-		fmt.Println("getVideoWidth parse error:", err, stdout.String())
+		fmt.Println("parse width error:", err, string(stdout))
 	}
 	return uint(result), nil
 }
@@ -306,39 +293,35 @@ func getVideoHeight(path string) (uint, error) {
 
 func getVideoFPS(path string) (float64, error) {
 
-	ffprobe := "ffprobe"
+	stdout, _, err := runFfprobe([]string{"-v", "error", "-select_streams",
-	args := []string{"-v", "error", "-select_streams",
 		"v:0", "-count_packets", "-show_entries",
-		"stream=r_frame_rate", "-of", "csv=p=0", path}
+		"stream=r_frame_rate", "-of", "csv=p=0", path})
-
-	fmt.Println(ffprobe, strings.Join(args, " "))
-
-	cmd := exec.Command(ffprobe, args...)
-
-	var stdout bytes.Buffer
-	cmd.Stdout = &stdout
-	err := cmd.Run()
 	if err != nil {
-		fmt.Println("getVideoFPS cmd error:", err)
+		log.Errorln("ffprobe error:", err)
 		return -1, err
 	}
 
-	parts := strings.Split(strings.TrimSpace(stdout.String()), "/")
+	stdoutStr := string(stdout)
+	parts := strings.Split(strings.TrimSpace(stdoutStr), "/")
 	if len(parts) != 2 {
-		fmt.Println("getVideoFPS split error:", err, stdout.String())
+		log.Errorln("output format error", err, stdoutStr)
+		return 0, err
 	}
 
 	num, err := strconv.ParseFloat(parts[0], 64)
 	if err != nil {
-		fmt.Println("getVideoFPS numerator parse error:", err, stdout.String())
+		log.Errorln("numerator parse error:", err, stdoutStr)
+		return 0, err
 	}
 
 	denom, err := strconv.ParseFloat(parts[1], 64)
 	if err != nil {
-		fmt.Println("getVideoFPS denominator parse error:", err, stdout.String())
+		log.Errorln("denominator parse error:", err, stdoutStr)
+		return 0, err
 	}
 	if denom == 0 {
-		fmt.Println("getVideoFPS denominator is zero error:", stdout.String())
+		log.Errorln("denominator is zero error:", stdoutStr)
+		return 0, err
 	}
 
 	return num / denom, nil
@@ -423,22 +406,16 @@ func getVideoMeta(path string) (VideoMeta, error) {
 
 func getAudioDuration(path string) (float64, error) {
 
-	ffprobe := "ffprobe"
+	stdout, _, err := runFfprobe([]string{
-	ffprobeArgs := []string{
 		"-v", "error",
 		"-show_entries", "format=duration",
 		"-of", "default=noprint_wrappers=1:nokey=1",
-		path}
+		path})
-	fmt.Println(ffprobe, strings.Join(ffprobeArgs, " "))
-	cmd := exec.Command(ffprobe, ffprobeArgs...)
-	var stdout bytes.Buffer
-	cmd.Stdout = &stdout
-	err := cmd.Run()
 	if err != nil {
-		fmt.Println("getAudioDuration error:", err, stdout.String())
+		log.Errorln("ffprobe error:", err)
 		return 0, err
 	}
-	durationStr := strings.TrimSpace(stdout.String())
+	durationStr := strings.TrimSpace(string(stdout))
 	return strconv.ParseFloat(durationStr, 64)
 }
 

logger.go

@@ -15,7 +15,7 @@ func initLogger() {
 
 	log = logrus.New()
 	log.SetOutput(os.Stdout)
-	log.SetLevel(logrus.DebugLevel)
+	log.SetLevel(logrus.InfoLevel)
 	log.SetFormatter(&logrus.TextFormatter{
 		FullTimestamp:   true,
 		TimestampFormat: "2006-01-02 15:04:05",

workers.go

@@ -16,7 +16,7 @@ import (
 
 func ensureDirFor(path string) error {
 	dir := filepath.Dir(path)
-	fmt.Println("Create", dir)
+	log.Debugln("Create", dir)
 	return os.MkdirAll(dir, 0700)
 }