feat: improve stragety when sources unavailable

Signed-off-by: Dennis Zhuang <killme2008@gmail.com>

Author: killme2008

cmd/devtap/drain.go

@@ -40,6 +40,10 @@ func runDrain(cmd *cobra.Command, args []string) error {
 	maxLines, _ := cmd.Flags().GetInt("max-lines")
 	filterSQL, _ := cmd.Flags().GetString("filter-sql")
 
+	if maxLines <= 0 {
+		maxLines = 10000
+	}
+
 	// If --filter-sql is set, fall back to single-source drain against the configured store.
 	if filterSQL != "" {
 		return runDrainSingleSource(cmd, filterSQL, maxLines, event, autoLoop, maxRetries)
@@ -53,6 +57,8 @@ func runDrain(cmd *cobra.Command, args []string) error {
 
 	multiSource := len(sources) > 1
 	var allMessages []store.LogMessage
+	var drainErrors []string
+	successCount := 0
 
 	// Track remaining message budget. Drain treats its limit as a message
 	// count, so the budget uses the same unit. Line-level truncation is
@@ -67,11 +73,13 @@ func runDrain(cmd *cobra.Command, args []string) error {
 		messages, err := src.Store.Drain(src.SessionID, remaining)
 		if err != nil {
 			if multiSource {
+				drainErrors = append(drainErrors, fmt.Sprintf("source %q: %v", src.Label, err))
 				fmt.Fprintf(cmd.ErrOrStderr(), "devtap: source %q unreachable: %v\n", src.Label, err)
 				continue
 			}
 			return fmt.Errorf("drain: %w", err)
 		}
+		successCount++
 
 		if multiSource {
 			for i := range messages {
@@ -87,6 +95,15 @@ func runDrain(cmd *cobra.Command, args []string) error {
 		remaining -= len(messages)
 	}
 
+	// All sources failed — return error rather than silently succeeding.
+	// Exception: Stop+autoLoop should fall through so the user isn't blocked.
+	if multiSource && successCount == 0 && len(drainErrors) > 0 {
+		if event != "Stop" || !autoLoop {
+			return fmt.Errorf("all sources failed: %s", strings.Join(drainErrors, "; "))
+		}
+		fmt.Fprintf(cmd.ErrOrStderr(), "devtap: all sources failed, allowing stop\n")
+	}
+
 	if multiSource && len(allMessages) > 0 {
 		allMessages = mcp.DedupMessages(allMessages)
 	}

cmd/devtap/storefactory.go

@@ -66,6 +66,31 @@ func openStoreByBackend(cfg *config.Config, backend, storeDir, adapter string) (
 	}
 }
 
+// openStoreStrict opens a store without fallback. Unlike openStoreByBackend,
+// a greptimedb failure returns an error instead of silently falling back to
+// the file store. This is appropriate for reader paths (drain / MCP) where
+// falling back would silently drain the wrong data.
+func openStoreStrict(cfg *config.Config, backend, storeDir, adapter string) (store.Store, error) {
+	switch backend {
+	case "", "file":
+		return filestore.New(storeDir, adapter)
+	case "greptimedb":
+		gs, err := greptimestore.New(cfg.Store.GreptimeDB, storeDir, adapter)
+		if err != nil {
+			return nil, fmt.Errorf("greptimedb: %w", err)
+		}
+		ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+		defer cancel()
+		if err := gs.Ping(ctx); err != nil {
+			_ = gs.Close()
+			return nil, fmt.Errorf("greptimedb ping: %w", err)
+		}
+		return gs, nil
+	default:
+		return nil, fmt.Errorf("unknown store backend: %q", backend)
+	}
+}
+
 // resolveDrainSources returns 1 or 2 drain sources for the MCP server and drain command.
 //
 // - "configured" source: from CLI --store/--session flags (or global config defaults)
@@ -108,10 +133,10 @@ func resolveDrainSources(cmd *cobra.Command) ([]mcp.DrainSource, func(), error)
 		}
 	}
 
-	configuredStore, err := openStoreByBackend(cfg, configuredBackend, storeDir, adapterName)
-	if err != nil {
-		return nil, nil, fmt.Errorf("open configured store: %w", err)
-	}
+	// Use strict open for the configured store so that a greptimedb failure
+	// is surfaced rather than silently falling back to the local file store
+	// (which would drain wrong data). On failure, degrade to local-only.
+	configuredStore, configuredErr := openStoreStrict(cfg, configuredBackend, storeDir, adapterName)
 
 	// Resolve "local" source: always use global config backend + auto-detected session.
 	localBackend := cfg.Store.Backend
@@ -128,6 +153,20 @@ func resolveDrainSources(cmd *cobra.Command) ([]mcp.DrainSource, func(), error)
 		return b
 	}
 
+	// Configured store unavailable — fall back to local-only single source.
+	if configuredErr != nil {
+		fmt.Fprintf(os.Stderr, "devtap: configured store %q unavailable (%v), using local only\n",
+			configuredBackend, configuredErr)
+		localStore, err := openStoreByBackend(cfg, localBackend, storeDir, adapterName)
+		if err != nil {
+			return nil, nil, fmt.Errorf("open local store: %w", err)
+		}
+		cleanup := func() { _ = localStore.Close() }
+		return []mcp.DrainSource{
+			{Store: localStore, SessionID: localSession, Label: localSession},
+		}, cleanup, nil
+	}
+
 	// If both sources resolve to the same (backend, session), single source.
 	if normBackend(configuredBackend) == normBackend(localBackend) && configuredSession == localSession {
 		cleanup := func() { _ = configuredStore.Close() }