Add better logging

internal/config/config.go

@@ -14,6 +14,7 @@ type Config struct {
 	Models        []ModelEntry             `yaml:"models"`
 	Auth          AuthConfig               `yaml:"auth"`
 	Conversations ConversationConfig       `yaml:"conversations"`
+	Logging       LoggingConfig            `yaml:"logging"`
 }
 
 // ConversationConfig controls conversation storage.
@@ -30,6 +31,14 @@ type ConversationConfig struct {
 	Driver string `yaml:"driver"`
 }
 
+// LoggingConfig controls logging format and level.
+type LoggingConfig struct {
+	// Format is the log output format: "json" (default) or "text".
+	Format string `yaml:"format"`
+	// Level is the minimum log level: "debug", "info" (default), "warn", or "error".
+	Level string `yaml:"level"`
+}
+
 // AuthConfig holds OIDC authentication settings.
 type AuthConfig struct {
 	Enabled  bool   `yaml:"enabled"`

internal/logger/logger.go

@@ -0,0 +1,59 @@
+package logger
+
+import (
+	"context"
+	"log/slog"
+	"os"
+)
+
+type contextKey string
+
+const requestIDKey contextKey = "request_id"
+
+// New creates a logger with the specified format (json or text) and level.
+func New(format string, level string) *slog.Logger {
+	var handler slog.Handler
+
+	logLevel := parseLevel(level)
+	opts := &slog.HandlerOptions{
+		Level:     logLevel,
+		AddSource: true, // Add file:line info for debugging
+	}
+
+	if format == "json" {
+		handler = slog.NewJSONHandler(os.Stdout, opts)
+	} else {
+		handler = slog.NewTextHandler(os.Stdout, opts)
+	}
+
+	return slog.New(handler)
+}
+
+// parseLevel converts a string level to slog.Level.
+func parseLevel(level string) slog.Level {
+	switch level {
+	case "debug":
+		return slog.LevelDebug
+	case "info":
+		return slog.LevelInfo
+	case "warn":
+		return slog.LevelWarn
+	case "error":
+		return slog.LevelError
+	default:
+		return slog.LevelInfo
+	}
+}
+
+// WithRequestID adds a request ID to the context for tracing.
+func WithRequestID(ctx context.Context, requestID string) context.Context {
+	return context.WithValue(ctx, requestIDKey, requestID)
+}
+
+// FromContext extracts the request ID from context, or returns empty string.
+func FromContext(ctx context.Context) string {
+	if id, ok := ctx.Value(requestIDKey).(string); ok {
+		return id
+	}
+	return ""
+}

internal/providers/google/google.go

@@ -21,7 +21,7 @@ type Provider struct {
 }
 
 // New constructs a Provider using the Google AI API with API key authentication.
-func New(cfg config.ProviderConfig) *Provider {
+func New(cfg config.ProviderConfig) (*Provider, error) {
 	var client *genai.Client
 	if cfg.APIKey != "" {
 		var err error
@@ -29,20 +29,19 @@ func New(cfg config.ProviderConfig) *Provider {
 			APIKey: cfg.APIKey,
 		})
 		if err != nil {
-			// Log error but don't fail construction - will fail on Generate
-			fmt.Printf("warning: failed to create google client: %v\n", err)
+			return nil, fmt.Errorf("failed to create google client: %w", err)
 		}
 	}
 	return &Provider{
 		cfg:    cfg,
 		client: client,
-	}
+	}, nil
 }
 
 // NewVertexAI constructs a Provider targeting Vertex AI.
 // Vertex AI uses the same genai SDK but with GCP project/location configuration
 // and Application Default Credentials (ADC) or service account authentication.
-func NewVertexAI(vertexCfg config.VertexAIConfig) *Provider {
+func NewVertexAI(vertexCfg config.VertexAIConfig) (*Provider, error) {
 	var client *genai.Client
 	if vertexCfg.Project != "" && vertexCfg.Location != "" {
 		var err error
@@ -52,8 +51,7 @@ func NewVertexAI(vertexCfg config.VertexAIConfig) *Provider {
 			Backend:  genai.BackendVertexAI,
 		})
 		if err != nil {
-			// Log error but don't fail construction - will fail on Generate
-			fmt.Printf("warning: failed to create vertex ai client: %v\n", err)
+			return nil, fmt.Errorf("failed to create vertex ai client: %w", err)
 		}
 	}
 	return &Provider{
@@ -62,7 +60,7 @@ func NewVertexAI(vertexCfg config.VertexAIConfig) *Provider {
 			APIKey: "",
 		},
 		client: client,
-	}
+	}, nil
 }
 
 func (p *Provider) Name() string { return Name }

internal/providers/providers.go

@@ -97,7 +97,7 @@ func buildProvider(entry config.ProviderEntry) (Provider, error) {
 		return googleprovider.New(config.ProviderConfig{
 			APIKey:   entry.APIKey,
 			Endpoint: entry.Endpoint,
-		}), nil
+		})
 	case "vertexai":
 		if entry.Project == "" || entry.Location == "" {
 			return nil, fmt.Errorf("project and location are required for vertexai")
@@ -105,7 +105,7 @@ func buildProvider(entry config.ProviderEntry) (Provider, error) {
 		return googleprovider.NewVertexAI(config.VertexAIConfig{
 			Project:  entry.Project,
 			Location: entry.Location,
-		}), nil
+		})
 	default:
 		return nil, fmt.Errorf("unknown provider type %q", entry.Type)
 	}

internal/server/mocks_test.go

@@ -3,7 +3,7 @@ package server
 import (
 	"context"
 	"fmt"
-	"log"
+	"log/slog"
 	"reflect"
 	"sync"
 	"unsafe"
@@ -250,8 +250,10 @@ func (m *mockLogger) getLogs() []string {
 	return append([]string{}, m.logs...)
 }
 
-func (m *mockLogger) asLogger() *log.Logger {
-	return log.New(m, "", 0)
+func (m *mockLogger) asLogger() *slog.Logger {
+	return slog.New(slog.NewTextHandler(m, &slog.HandlerOptions{
+		Level: slog.LevelDebug,
+	}))
 }
 
 func (m *mockLogger) Write(p []byte) (n int, err error) {

internal/server/server.go

@@ -3,7 +3,7 @@ package server
 import (
 	"encoding/json"
 	"fmt"
-	"log"
+	"log/slog"
 	"net/http"
 	"strings"
 	"time"
@@ -12,6 +12,7 @@ import (
 
 	"github.com/ajac-zero/latticelm/internal/api"
 	"github.com/ajac-zero/latticelm/internal/conversation"
+	"github.com/ajac-zero/latticelm/internal/logger"
 	"github.com/ajac-zero/latticelm/internal/providers"
 )
 
@@ -27,11 +28,11 @@ type ProviderRegistry interface {
 type GatewayServer struct {
 	registry ProviderRegistry
 	convs    conversation.Store
-	logger   *log.Logger
+	logger   *slog.Logger
 }
 
 // New creates a GatewayServer bound to the provider registry.
-func New(registry ProviderRegistry, convs conversation.Store, logger *log.Logger) *GatewayServer {
+func New(registry ProviderRegistry, convs conversation.Store, logger *slog.Logger) *GatewayServer {
 	return &GatewayServer{
 		registry: registry,
 		convs:    convs,
@@ -94,11 +95,19 @@ func (s *GatewayServer) handleResponses(w http.ResponseWriter, r *http.Request)
 	if req.PreviousResponseID != nil && *req.PreviousResponseID != "" {
 		conv, err := s.convs.Get(*req.PreviousResponseID)
 		if err != nil {
-			s.logger.Printf("error retrieving conversation: %v", err)
+			s.logger.ErrorContext(r.Context(), "failed to retrieve conversation",
+				slog.String("request_id", logger.FromContext(r.Context())),
+				slog.String("conversation_id", *req.PreviousResponseID),
+				slog.String("error", err.Error()),
+			)
 			http.Error(w, "error retrieving conversation", http.StatusInternalServerError)
 			return
 		}
 		if conv == nil {
+			s.logger.WarnContext(r.Context(), "conversation not found",
+				slog.String("request_id", logger.FromContext(r.Context())),
+				slog.String("conversation_id", *req.PreviousResponseID),
+			)
 			http.Error(w, "conversation not found", http.StatusNotFound)
 			return
 		}
@@ -140,7 +149,12 @@ func (s *GatewayServer) handleResponses(w http.ResponseWriter, r *http.Request)
 func (s *GatewayServer) handleSyncResponse(w http.ResponseWriter, r *http.Request, provider providers.Provider, providerMsgs []api.Message, resolvedReq *api.ResponseRequest, origReq *api.ResponseRequest, storeMsgs []api.Message) {
 	result, err := provider.Generate(r.Context(), providerMsgs, resolvedReq)
 	if err != nil {
-		s.logger.Printf("provider %s error: %v", provider.Name(), err)
+		s.logger.ErrorContext(r.Context(), "provider generation failed",
+			slog.String("request_id", logger.FromContext(r.Context())),
+			slog.String("provider", provider.Name()),
+			slog.String("model", resolvedReq.Model),
+			slog.String("error", err.Error()),
+		)
 		http.Error(w, "provider error", http.StatusBadGateway)
 		return
 	}
@@ -155,10 +169,24 @@ func (s *GatewayServer) handleSyncResponse(w http.ResponseWriter, r *http.Reques
 	}
 	allMsgs := append(storeMsgs, assistantMsg)
 	if _, err := s.convs.Create(responseID, result.Model, allMsgs); err != nil {
-		s.logger.Printf("error storing conversation: %v", err)
+		s.logger.ErrorContext(r.Context(), "failed to store conversation",
+			slog.String("request_id", logger.FromContext(r.Context())),
+			slog.String("response_id", responseID),
+			slog.String("error", err.Error()),
+		)
 		// Don't fail the response if storage fails
 	}
 
+	s.logger.InfoContext(r.Context(), "response generated",
+		slog.String("request_id", logger.FromContext(r.Context())),
+		slog.String("provider", provider.Name()),
+		slog.String("model", result.Model),
+		slog.String("response_id", responseID),
+		slog.Int("input_tokens", result.Usage.InputTokens),
+		slog.Int("output_tokens", result.Usage.OutputTokens),
+		slog.Bool("has_tool_calls", len(result.ToolCalls) > 0),
+	)
+
 	// Build spec-compliant response
 	resp := s.buildResponse(origReq, result, provider.Name(), responseID)
 
@@ -335,13 +363,20 @@ loop:
 			}
 			break loop
 		case <-r.Context().Done():
-			s.logger.Printf("client disconnected")
+			s.logger.InfoContext(r.Context(), "client disconnected",
+				slog.String("request_id", logger.FromContext(r.Context())),
+			)
 			return
 		}
 	}
 
 	if streamErr != nil {
-		s.logger.Printf("stream error: %v", streamErr)
+		s.logger.ErrorContext(r.Context(), "stream error",
+			slog.String("request_id", logger.FromContext(r.Context())),
+			slog.String("provider", provider.Name()),
+			slog.String("model", origReq.Model),
+			slog.String("error", streamErr.Error()),
+		)
 		failedResp := s.buildResponse(origReq, &api.ProviderResult{
 			Model: origReq.Model,
 		}, provider.Name(), responseID)
@@ -477,9 +512,21 @@ loop:
 		}
 		allMsgs := append(storeMsgs, assistantMsg)
 		if _, err := s.convs.Create(responseID, model, allMsgs); err != nil {
-			s.logger.Printf("error storing conversation: %v", err)
+			s.logger.ErrorContext(r.Context(), "failed to store conversation",
+				slog.String("request_id", logger.FromContext(r.Context())),
+				slog.String("response_id", responseID),
+				slog.String("error", err.Error()),
+			)
 			// Don't fail the response if storage fails
 		}
+
+		s.logger.InfoContext(r.Context(), "streaming response completed",
+			slog.String("request_id", logger.FromContext(r.Context())),
+			slog.String("provider", provider.Name()),
+			slog.String("model", model),
+			slog.String("response_id", responseID),
+			slog.Bool("has_tool_calls", len(toolCalls) > 0),
+		)
 	}
 }
 
@@ -488,7 +535,10 @@ func (s *GatewayServer) sendSSE(w http.ResponseWriter, flusher http.Flusher, seq
 	*seq++
 	data, err := json.Marshal(event)
 	if err != nil {
-		s.logger.Printf("failed to marshal SSE event: %v", err)
+		s.logger.Error("failed to marshal SSE event",
+			slog.String("event_type", eventType),
+			slog.String("error", err.Error()),
+		)
 		return
 	}
 	fmt.Fprintf(w, "event: %s\ndata: %s\n\n", eventType, data)