snapshot of https://github.com/seaweedfs/seaweedfs.git (master, 2026-09-16; blobs > 131072B omitted)

weed/worker/tasks/task_logger.go

@@ -0,0 +1,444 @@
+package tasks
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"sort"
+	"sync"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/glog"
+	"github.com/seaweedfs/seaweedfs/weed/worker/types"
+)
+
+// TaskLogger provides file-based logging for individual tasks
+type TaskLogger interface {
+	// Log methods
+	Info(message string, args ...interface{})
+	Warning(message string, args ...interface{})
+	Error(message string, args ...interface{})
+	Debug(message string, args ...interface{})
+
+	// Progress and status logging
+	LogProgress(progress float64, message string)
+	LogStatus(status string, message string)
+
+	// Structured logging
+	LogWithFields(level string, message string, fields map[string]interface{})
+
+	// Lifecycle
+	Sync() error
+	Close() error
+	GetLogDir() string
+}
+
+// LoggerProvider interface for tasks that support logging
+type LoggerProvider interface {
+	InitializeTaskLogger(taskID string, workerID string, params types.TaskParams) error
+	GetTaskLogger() TaskLogger
+}
+
+// TaskLoggerConfig holds configuration for task logging
+type TaskLoggerConfig struct {
+	BaseLogDir    string
+	MaxTasks      int  // Maximum number of task logs to keep
+	MaxLogSizeMB  int  // Maximum log file size in MB
+	EnableConsole bool // Also log to console
+}
+
+// FileTaskLogger implements TaskLogger using file-based logging
+type FileTaskLogger struct {
+	taskID   string
+	taskType types.TaskType
+	workerID string
+	logDir   string
+	logFile  *os.File
+	mutex    sync.Mutex
+	config   TaskLoggerConfig
+	metadata *TaskLogMetadata
+	closed   bool
+}
+
+// TaskLogMetadata contains metadata about the task execution
+type TaskLogMetadata struct {
+	TaskID      string                 `json:"task_id"`
+	TaskType    string                 `json:"task_type"`
+	WorkerID    string                 `json:"worker_id"`
+	StartTime   time.Time              `json:"start_time"`
+	EndTime     *time.Time             `json:"end_time,omitempty"`
+	Duration    *time.Duration         `json:"duration,omitempty"`
+	Status      string                 `json:"status"`
+	Progress    float64                `json:"progress"`
+	VolumeID    uint32                 `json:"volume_id,omitempty"`
+	Server      string                 `json:"server,omitempty"`
+	Collection  string                 `json:"collection,omitempty"`
+	CustomData  map[string]interface{} `json:"custom_data,omitempty"`
+	LogFilePath string                 `json:"log_file_path"`
+	CreatedAt   time.Time              `json:"created_at"`
+}
+
+// TaskLogEntry represents a single log entry
+type TaskLogEntry struct {
+	Timestamp time.Time              `json:"timestamp"`
+	Level     string                 `json:"level"`
+	Message   string                 `json:"message"`
+	Fields    map[string]interface{} `json:"fields,omitempty"`
+	Progress  *float64               `json:"progress,omitempty"`
+	Status    *string                `json:"status,omitempty"`
+}
+
+// DefaultTaskLoggerConfig returns default configuration
+func DefaultTaskLoggerConfig() TaskLoggerConfig {
+	return TaskLoggerConfig{
+		BaseLogDir:    "/data/task_logs", // Use persistent data directory
+		MaxTasks:      100,               // Keep last 100 task logs
+		MaxLogSizeMB:  10,
+		EnableConsole: true,
+	}
+}
+
+// NewTaskLogger creates a new file-based task logger
+func NewTaskLogger(taskID string, taskType types.TaskType, workerID string, params types.TaskParams, config TaskLoggerConfig) (TaskLogger, error) {
+	// Create unique directory name with timestamp
+	timestamp := time.Now().Format("20060102_150405")
+	dirName := fmt.Sprintf("%s_%s_%s_%s", taskID, taskType, workerID, timestamp)
+	logDir := filepath.Join(config.BaseLogDir, dirName)
+
+	// Create log directory
+	if err := os.MkdirAll(logDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create log directory %s: %w", logDir, err)
+	}
+
+	// Create log file
+	logFilePath := filepath.Join(logDir, "task.log")
+	logFile, err := os.OpenFile(logFilePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create log file %s: %w", logFilePath, err)
+	}
+
+	// Create metadata
+	metadata := &TaskLogMetadata{
+		TaskID:      taskID,
+		TaskType:    string(taskType),
+		WorkerID:    workerID,
+		StartTime:   time.Now(),
+		Status:      "started",
+		Progress:    0.0,
+		VolumeID:    params.VolumeID,
+		Server:      getServerFromSources(params.TypedParams.Sources),
+		Collection:  params.Collection,
+		CustomData:  make(map[string]interface{}),
+		LogFilePath: logFilePath,
+		CreatedAt:   time.Now(),
+	}
+
+	logger := &FileTaskLogger{
+		taskID:   taskID,
+		taskType: taskType,
+		workerID: workerID,
+		logDir:   logDir,
+		logFile:  logFile,
+		config:   config,
+		metadata: metadata,
+		closed:   false,
+	}
+
+	// Write initial log entry
+	logger.Info("Task logger initialized for %s (type: %s, worker: %s)", taskID, taskType, workerID)
+	logger.LogWithFields("INFO", "Task parameters", map[string]interface{}{
+		"volume_id":  params.VolumeID,
+		"server":     getServerFromSources(params.TypedParams.Sources),
+		"collection": params.Collection,
+	})
+
+	// Save initial metadata
+	if err := logger.saveMetadata(); err != nil {
+		glog.Warningf("Failed to save initial task metadata: %v", err)
+	}
+
+	// Clean up old task logs
+	go logger.cleanupOldLogs()
+
+	return logger, nil
+}
+
+// Info logs an info message
+func (l *FileTaskLogger) Info(message string, args ...interface{}) {
+	l.log("INFO", message, args...)
+}
+
+// Warning logs a warning message
+func (l *FileTaskLogger) Warning(message string, args ...interface{}) {
+	l.log("WARNING", message, args...)
+}
+
+// Error logs an error message
+func (l *FileTaskLogger) Error(message string, args ...interface{}) {
+	l.log("ERROR", message, args...)
+}
+
+// Debug logs a debug message
+func (l *FileTaskLogger) Debug(message string, args ...interface{}) {
+	l.log("DEBUG", message, args...)
+}
+
+// LogProgress logs task progress
+func (l *FileTaskLogger) LogProgress(progress float64, message string) {
+	l.mutex.Lock()
+	l.metadata.Progress = progress
+	l.mutex.Unlock()
+
+	entry := TaskLogEntry{
+		Timestamp: time.Now(),
+		Level:     "INFO",
+		Message:   message,
+		Progress:  &progress,
+	}
+
+	l.writeLogEntry(entry)
+	// Update metadata with new progress
+	if err := l.saveMetadata(); err != nil {
+		glog.Warningf("Failed to save initial task metadata: %v", err)
+	}
+}
+
+// LogStatus logs task status change
+func (l *FileTaskLogger) LogStatus(status string, message string) {
+	l.mutex.Lock()
+	l.metadata.Status = status
+	l.mutex.Unlock()
+
+	entry := TaskLogEntry{
+		Timestamp: time.Now(),
+		Level:     "INFO",
+		Message:   message,
+		Status:    &status,
+	}
+
+	l.writeLogEntry(entry)
+	// Update metadata with new status
+	if err := l.saveMetadata(); err != nil {
+		glog.Warningf("Failed to update metadata with new status: %v", err)
+	}
+}
+
+// LogWithFields logs a message with structured fields
+func (l *FileTaskLogger) LogWithFields(level string, message string, fields map[string]interface{}) {
+	entry := TaskLogEntry{
+		Timestamp: time.Now(),
+		Level:     level,
+		Message:   message,
+		Fields:    fields,
+	}
+
+	l.writeLogEntry(entry)
+}
+
+// Sync flushes buffered data to disk
+func (l *FileTaskLogger) Sync() error {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+
+	if l.logFile != nil {
+		return l.logFile.Sync()
+	}
+	return nil
+}
+
+// Close closes the logger and finalizes metadata
+func (l *FileTaskLogger) Close() error {
+	l.Info("Task logger closed for %s", l.taskID)
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+
+	if l.closed {
+		return nil
+	}
+
+	// Finalize metadata
+	endTime := time.Now()
+	duration := endTime.Sub(l.metadata.StartTime)
+	l.metadata.EndTime = &endTime
+	l.metadata.Duration = &duration
+
+	if l.metadata.Status == "started" {
+		l.metadata.Status = "completed"
+	}
+
+	// Save final metadata
+	if err := l.saveMetadata(); err != nil {
+		glog.Warningf("Failed to save final task metadata: %v", err)
+	}
+
+	// Close log file
+	if l.logFile != nil {
+		if err := l.logFile.Close(); err != nil {
+			return fmt.Errorf("failed to close log file: %w", err)
+		}
+	}
+
+	l.closed = true
+
+	return nil
+}
+
+// GetLogDir returns the log directory path
+func (l *FileTaskLogger) GetLogDir() string {
+	return l.logDir
+}
+
+// log is the internal logging method
+func (l *FileTaskLogger) log(level string, message string, args ...interface{}) {
+	formattedMessage := fmt.Sprintf(message, args...)
+
+	entry := TaskLogEntry{
+		Timestamp: time.Now(),
+		Level:     level,
+		Message:   formattedMessage,
+	}
+
+	l.writeLogEntry(entry)
+}
+
+// writeLogEntry writes a log entry to the file
+func (l *FileTaskLogger) writeLogEntry(entry TaskLogEntry) {
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+
+	if l.closed || l.logFile == nil {
+		return
+	}
+
+	// Format as JSON line
+	jsonData, err := json.Marshal(entry)
+	if err != nil {
+		glog.Errorf("Failed to marshal log entry: %v", err)
+		return
+	}
+
+	// Write to file
+	if _, err := l.logFile.WriteString(string(jsonData) + "\n"); err != nil {
+		glog.Errorf("Failed to write log entry: %v", err)
+		return
+	}
+
+	// Only forward errors and warnings to glog; routine task logs stay in the task log file.
+	if l.config.EnableConsole {
+		formattedMsg := fmt.Sprintf("[TASK-%s] %s: %s", l.taskID, entry.Level, entry.Message)
+		switch entry.Level {
+		case "ERROR":
+			glog.ErrorDepth(4, formattedMsg)
+		case "WARNING":
+			glog.WarningDepth(4, formattedMsg)
+		}
+	}
+}
+
+// saveMetadata saves task metadata to file
+func (l *FileTaskLogger) saveMetadata() error {
+	metadataPath := filepath.Join(l.logDir, "metadata.json")
+
+	data, err := json.MarshalIndent(l.metadata, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal metadata: %w", err)
+	}
+
+	return os.WriteFile(metadataPath, data, 0644)
+}
+
+// cleanupOldLogs removes old task log directories to maintain the limit
+func (l *FileTaskLogger) cleanupOldLogs() {
+	baseDir := l.config.BaseLogDir
+
+	entries, err := os.ReadDir(baseDir)
+	if err != nil {
+		glog.Warningf("Failed to read log directory %s: %v", baseDir, err)
+		return
+	}
+
+	// Filter for directories only
+	var dirs []os.DirEntry
+	for _, entry := range entries {
+		if entry.IsDir() {
+			dirs = append(dirs, entry)
+		}
+	}
+
+	// If we're under the limit, nothing to clean
+	if len(dirs) <= l.config.MaxTasks {
+		return
+	}
+
+	// Sort by modification time (oldest first)
+	sort.Slice(dirs, func(i, j int) bool {
+		infoI, errI := dirs[i].Info()
+		infoJ, errJ := dirs[j].Info()
+		if errI != nil || errJ != nil {
+			return false
+		}
+		return infoI.ModTime().Before(infoJ.ModTime())
+	})
+
+	// Remove oldest directories
+	numToRemove := len(dirs) - l.config.MaxTasks
+	for i := 0; i < numToRemove; i++ {
+		dirPath := filepath.Join(baseDir, dirs[i].Name())
+		if err := os.RemoveAll(dirPath); err != nil {
+			glog.Warningf("Failed to remove old log directory %s: %v", dirPath, err)
+		} else {
+			glog.V(1).Infof("Cleaned up old task log directory: %s", dirPath)
+		}
+	}
+
+	glog.V(1).Infof("Task log cleanup completed: removed %d old directories", numToRemove)
+}
+
+// GetTaskLogMetadata reads metadata from a task log directory
+func GetTaskLogMetadata(logDir string) (*TaskLogMetadata, error) {
+	metadataPath := filepath.Join(logDir, "metadata.json")
+
+	data, err := os.ReadFile(metadataPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read metadata file: %w", err)
+	}
+
+	var metadata TaskLogMetadata
+	if err := json.Unmarshal(data, &metadata); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal metadata: %w", err)
+	}
+
+	return &metadata, nil
+}
+
+// ReadTaskLogs reads all log entries from a task log file
+func ReadTaskLogs(logDir string) ([]TaskLogEntry, error) {
+	logPath := filepath.Join(logDir, "task.log")
+
+	file, err := os.Open(logPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open log file: %w", err)
+	}
+	defer file.Close()
+
+	var entries []TaskLogEntry
+	decoder := json.NewDecoder(file)
+
+	for {
+		var entry TaskLogEntry
+		if err := decoder.Decode(&entry); err != nil {
+			if err == io.EOF {
+				break
+			}
+			// If we fail to decode an entry, it might be a partial write at the end of the file
+			// Return what we have so far instead of failing the entire request
+			glog.V(1).Infof("Failed to decode log entry in %s: %v (returning %d partial logs)", logPath, err, len(entries))
+			break
+		}
+		entries = append(entries, entry)
+	}
+
+	return entries, nil
+}