Implement DMR log streaming via /logs endpoint (#807)

* feat: implement DMR log streaming via /logs endpoint with follow and no-engines options

* fix: surface errors when tailing engine log to prevent silent failures

Author: ilopezluna

cmd/cli/commands/logs.go

@@ -1,29 +1,23 @@
 package commands
 
 import (
-	"bufio"
 	"context"
 	"errors"
 	"fmt"
-	"io"
 	"os"
 	"os/exec"
-	"os/signal"
 	"path/filepath"
-	"regexp"
 	"runtime"
 	"strings"
-	"time"
 
 	"github.com/docker/model-runner/cmd/cli/commands/completion"
 	"github.com/docker/model-runner/cmd/cli/desktop"
 	"github.com/docker/model-runner/cmd/cli/pkg/standalone"
 	"github.com/docker/model-runner/cmd/cli/pkg/types"
+	dmrlogs "github.com/docker/model-runner/pkg/logs"
 	"github.com/moby/moby/api/pkg/stdcopy"
 	"github.com/moby/moby/client"
-	"github.com/nxadm/tail"
 	"github.com/spf13/cobra"
-	"golang.org/x/sync/errgroup"
 )
 
 func newLogsCmd() *cobra.Command {
@@ -32,135 +26,98 @@ func newLogsCmd() *cobra.Command {
 		Use:   "logs [OPTIONS]",
 		Short: "Fetch the Docker Model Runner logs",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			homeDir, err := os.UserHomeDir()
-			if err != nil {
-				return err
-			}
-
-			// If we're running in standalone mode, then print the container
-			// logs.
+			// Standalone mode: fetch container logs via Docker API.
 			engineKind := modelRunner.EngineKind()
 			useStandaloneLogs := engineKind == types.ModelRunnerEngineKindMoby ||
 				engineKind == types.ModelRunnerEngineKindCloud
 			if useStandaloneLogs {
-				dockerClient, err := desktop.DockerClientForContext(dockerCLI, dockerCLI.CurrentContext())
+				dockerClient, err := desktop.DockerClientForContext(
+					dockerCLI, dockerCLI.CurrentContext(),
+				)
 				if err != nil {
 					return fmt.Errorf("failed to create Docker client: %w", err)
 				}
-				ctrID, _, _, err := standalone.FindControllerContainer(cmd.Context(), dockerClient)
+				ctrID, _, _, err := standalone.FindControllerContainer(
+					cmd.Context(), dockerClient,
+				)
 				if err != nil {
-					return fmt.Errorf("unable to identify Model Runner container: %w", err)
+					return fmt.Errorf(
+						"unable to identify Model Runner container: %w", err,
+					)
 				} else if ctrID == "" {
 					return errors.New("unable to identify Model Runner container")
 				}
-				log, err := dockerClient.ContainerLogs(cmd.Context(), ctrID, client.ContainerLogsOptions{
-					ShowStdout: true,
-					ShowStderr: true,
-					Follow:     follow,
-				})
+				log, err := dockerClient.ContainerLogs(
+					cmd.Context(), ctrID, client.ContainerLogsOptions{
+						ShowStdout: true,
+						ShowStderr: true,
+						Follow:     follow,
+					},
+				)
 				if err != nil {
-					return fmt.Errorf("unable to query Model Runner container logs: %w", err)
+					return fmt.Errorf(
+						"unable to query Model Runner container logs: %w", err,
+					)
 				}
 				defer log.Close()
 				_, err = stdcopy.StdCopy(os.Stdout, os.Stderr, log)
 				return err
 			}
 
-			var serviceLogPath string
-			var runtimeLogPath string
-			switch runtime.GOOS {
-			case "darwin":
-				serviceLogPath = filepath.Join(homeDir, "Library/Containers/com.docker.docker/Data/log/host/inference.log")
-				runtimeLogPath = filepath.Join(homeDir, "Library/Containers/com.docker.docker/Data/log/host/inference-llama.cpp-server.log")
-			case "windows", "linux":
-				baseDir := homeDir
-				if runtime.GOOS == "linux" {
-					if !isWSL() {
-						return fmt.Errorf("log viewing on native Linux is only supported in standalone mode")
-					}
-					// When running inside WSL2 with Docker Desktop, the log files
-					// are on the Windows host filesystem mounted under /mnt/.
-					winHomeDir, wslErr := windowsHomeDirFromWSL(cmd.Context())
-					if wslErr != nil {
-						return fmt.Errorf("unable to determine Windows home directory from WSL2: %w", wslErr)
-					}
-					baseDir = winHomeDir
+			// Desktop mode: try local log files first.
+			serviceLogPath, runtimeLogPath, localErr := resolveDesktopLogPaths(
+				cmd.Context(),
+			)
+			if localErr == nil {
+				// Verify we can actually open the service log.
+				f, openErr := os.Open(serviceLogPath)
+				if openErr != nil {
+					localErr = openErr
+				} else {
+					f.Close()
 				}
-				serviceLogPath = filepath.Join(baseDir, "AppData/Local/Docker/log/host/inference.log")
-				runtimeLogPath = filepath.Join(baseDir, "AppData/Local/Docker/log/host/inference-llama.cpp-server.log")
-			default:
-				return fmt.Errorf("unsupported OS: %s", runtime.GOOS)
 			}
 
-			if noEngines {
-				err = printMergedLog(cmd.OutOrStdout(), serviceLogPath, "")
-				if err != nil {
-					return err
-				}
-			} else {
-				err = printMergedLog(cmd.OutOrStdout(), serviceLogPath, runtimeLogPath)
-				if err != nil {
-					return err
+			if localErr != nil {
+				// Local files unavailable (e.g. running inside a container).
+				// Fall back to the DMR /logs API.
+				apiErr := desktopClient.Logs(
+					cmd.Context(), follow, noEngines, cmd.OutOrStdout(),
+				)
+				if apiErr != nil {
+					return fmt.Errorf(
+						"local logs unavailable (%w); API fallback failed: %w",
+						localErr, apiErr,
+					)
 				}
-			}
-
-			if !follow {
 				return nil
 			}
 
-			ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, os.Kill)
-			defer cancel()
-
-			g, ctx := errgroup.WithContext(ctx)
-
-			// Poll mode is needed when tailing files over a mounted filesystem
-			// (Windows or WSL2 accessing the Windows host via /mnt/).
-			pollMode := runtime.GOOS == "windows" || (runtime.GOOS == "linux" && isWSL())
-
-			g.Go(func() error {
-				t, err := tail.TailFile(
-					serviceLogPath, tail.Config{Location: &tail.SeekInfo{Offset: 0, Whence: io.SeekEnd}, Follow: true, ReOpen: true, Poll: pollMode},
-				)
-				if err != nil {
-					return err
-				}
-				for {
-					select {
-					case line, ok := <-t.Lines:
-						if !ok {
-							return nil
-						}
-						cmd.Println(line.Text)
-					case <-ctx.Done():
-						return t.Stop()
-					}
-				}
-			})
-
+			// Local files are accessible: use shared merge/follow logic.
+			enginePath := ""
 			if !noEngines {
-				g.Go(func() error {
-					t, err := tail.TailFile(
-						runtimeLogPath, tail.Config{Location: &tail.SeekInfo{Offset: 0, Whence: io.SeekEnd}, Follow: true, ReOpen: true, Poll: pollMode},
-					)
-					if err != nil {
-						return err
-					}
-
-					for {
-						select {
-						case line, ok := <-t.Lines:
-							if !ok {
-								return nil
-							}
-							cmd.Println(line.Text)
-						case <-ctx.Done():
-							return t.Stop()
-						}
-					}
-				})
+				enginePath = runtimeLogPath
 			}
 
-			return g.Wait()
+			// Poll mode is needed when tailing files over a mounted
+			// filesystem (Windows or WSL2 accessing the Windows host).
+			pollMode := runtime.GOOS == "windows" ||
+				(runtime.GOOS == "linux" && isWSL())
+
+			result, err := dmrlogs.MergeLogs(
+				cmd.OutOrStdout(), serviceLogPath, enginePath,
+			)
+			if err != nil {
+				return err
+			}
+			if !follow {
+				return nil
+			}
+			return dmrlogs.Follow(
+				cmd.Context(), cmd.OutOrStdout(),
+				serviceLogPath, enginePath,
+				result, pollMode,
+			)
 		},
 		ValidArgsFunction: completion.NoComplete,
 	}
@@ -169,15 +126,64 @@ func newLogsCmd() *cobra.Command {
 	return c
 }
 
-// isWSL reports whether the current process is running inside a WSL2 environment.
+// resolveDesktopLogPaths returns the service and engine log file paths
+// for Docker Desktop mode. It returns an error when the OS is not
+// supported or path discovery fails (e.g. native Linux, WSL failure).
+func resolveDesktopLogPaths(ctx context.Context) (string, string, error) {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return "", "", fmt.Errorf("home directory: %w", err)
+	}
+
+	switch runtime.GOOS {
+	case "darwin":
+		base := filepath.Join(
+			homeDir,
+			"Library/Containers/com.docker.docker/Data/log/host",
+		)
+		return filepath.Join(base, dmrlogs.ServiceLogName),
+			filepath.Join(base, dmrlogs.EngineLogName),
+			nil
+	case "windows":
+		base := filepath.Join(homeDir, "AppData/Local/Docker/log/host")
+		return filepath.Join(base, dmrlogs.ServiceLogName),
+			filepath.Join(base, dmrlogs.EngineLogName),
+			nil
+	case "linux":
+		if !isWSL() {
+			return "", "", fmt.Errorf(
+				"log viewing on native Linux is only supported in standalone mode",
+			)
+		}
+		// In WSL2 with Docker Desktop, log files are on the Windows
+		// host filesystem mounted under /mnt/.
+		winHomeDir, wslErr := windowsHomeDirFromWSL(ctx)
+		if wslErr != nil {
+			return "", "", fmt.Errorf(
+				"unable to determine Windows home directory from WSL2: %w",
+				wslErr,
+			)
+		}
+		base := filepath.Join(winHomeDir, "AppData/Local/Docker/log/host")
+		return filepath.Join(base, dmrlogs.ServiceLogName),
+			filepath.Join(base, dmrlogs.EngineLogName),
+			nil
+	default:
+		return "", "", fmt.Errorf("unsupported OS: %s", runtime.GOOS)
+	}
+}
+
+// isWSL reports whether the current process is running inside a WSL2
+// environment.
 func isWSL() bool {
 	_, ok := os.LookupEnv("WSL_DISTRO_NAME")
 	return ok
 }
 
-// windowsHomeDirFromWSL resolves the Windows user's home directory from
-// within a WSL2 environment by running "wslpath" on the USERPROFILE path
-// obtained via "wslvar". This returns a Linux path like /mnt/c/Users/Name.
+// windowsHomeDirFromWSL resolves the Windows user's home directory
+// from within a WSL2 environment by running "wslpath" on the
+// USERPROFILE path obtained via "wslvar". Returns a Linux path such
+// as /mnt/c/Users/Name.
 func windowsHomeDirFromWSL(ctx context.Context) (string, error) {
 	out, err := exec.CommandContext(ctx, "wslvar", "USERPROFILE").Output()
 	if err != nil {
@@ -197,82 +203,3 @@ func windowsHomeDirFromWSL(ctx context.Context) (string, error) {
 	}
 	return linuxPath, nil
 }
-
-var timestampRe = regexp.MustCompile(`\[(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z)\].*`)
-
-const timeFmt = "2006-01-02T15:04:05.000000000Z"
-
-func advanceToNextTimestamp(w io.Writer, logScanner *bufio.Scanner) (time.Time, string) {
-	if logScanner == nil {
-		return time.Time{}, ""
-	}
-
-	for logScanner.Scan() {
-		text := logScanner.Text()
-		match := timestampRe.FindStringSubmatch(text)
-		if len(match) == 2 {
-			timestamp, err := time.Parse(timeFmt, match[1])
-			if err != nil {
-				fmt.Fprintln(w, text)
-				continue
-			}
-			return timestamp, text
-		} else {
-			fmt.Fprintln(w, text)
-		}
-	}
-	return time.Time{}, ""
-}
-
-func printMergedLog(w io.Writer, logPath1, logPath2 string) error {
-	var logScanner1 *bufio.Scanner
-	if logPath1 != "" {
-		logFile1, err := os.Open(logPath1)
-		if err == nil {
-			defer logFile1.Close()
-			logScanner1 = bufio.NewScanner(logFile1)
-		}
-	}
-
-	var logScanner2 *bufio.Scanner
-	if logPath2 != "" {
-		logFile2, err := os.Open(logPath2)
-		if err == nil {
-			defer logFile2.Close()
-			logScanner2 = bufio.NewScanner(logFile2)
-		}
-	}
-
-	var timestamp1 time.Time
-	var timestamp2 time.Time
-	var line1 string
-	var line2 string
-
-	timestamp1, line1 = advanceToNextTimestamp(w, logScanner1)
-	timestamp2, line2 = advanceToNextTimestamp(w, logScanner2)
-
-	for line1 != "" && line2 != "" {
-		if !timestamp2.Before(timestamp1) {
-			fmt.Fprintln(w, line1)
-			timestamp1, line1 = advanceToNextTimestamp(w, logScanner1)
-		} else {
-			fmt.Fprintln(w, line2)
-			timestamp2, line2 = advanceToNextTimestamp(w, logScanner2)
-		}
-	}
-
-	if line1 != "" {
-		fmt.Fprintln(w, line1)
-		for logScanner1.Scan() {
-			fmt.Fprintln(w, logScanner1.Text())
-		}
-	}
-	if line2 != "" {
-		fmt.Fprintln(w, line2)
-		for logScanner2.Scan() {
-			fmt.Fprintln(w, logScanner2.Text())
-		}
-	}
-
-	return nil
-}