Add LogParser and Logger utilities

Author: stringintech

utils/log_entry.go

@@ -0,0 +1,58 @@
+package utils
+
+import (
+	"log/slog"
+	"time"
+)
+
+// LogEntry represents a parsed log message with extracted components
+type LogEntry struct {
+	Time       time.Time
+	Thread     string
+	Category   string
+	Level      slog.Level
+	Source     string
+	Function   string
+	File       string
+	Path       string
+	LineNumber int
+	Message    string
+}
+
+func (entry *LogEntry) GetSlogAttributes() []slog.Attr {
+	var attrs []slog.Attr
+
+	if !entry.Time.IsZero() {
+		attrs = append(attrs, slog.Time("time", entry.Time))
+	}
+
+	if entry.Thread != "" {
+		attrs = append(attrs, slog.String("thread", entry.Thread))
+	}
+
+	if entry.Category != "" {
+		attrs = append(attrs, slog.String("category", entry.Category))
+	}
+
+	if entry.Source != "" {
+		attrs = append(attrs, slog.String("source", entry.Source))
+	}
+
+	if entry.Path != "" {
+		attrs = append(attrs, slog.String("path", entry.Path))
+	}
+
+	if entry.File != "" {
+		attrs = append(attrs, slog.String("file", entry.File))
+	}
+
+	if entry.LineNumber > 0 {
+		attrs = append(attrs, slog.Int("line_number", entry.LineNumber))
+	}
+
+	if entry.Function != "" {
+		attrs = append(attrs, slog.String("function", entry.Function))
+	}
+
+	return attrs
+}

utils/log_parser.go

@@ -0,0 +1,167 @@
+package utils
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"log/slog"
+
+	"github.com/stringintech/go-bitcoinkernel/kernel"
+)
+
+// LogParser handles parsing of raw log messages from Kernel
+type LogParser struct {
+	masterRegex *regexp.Regexp
+	options     kernel.LoggingOptions
+}
+
+func NewLogParser(options kernel.LoggingOptions) (*LogParser, error) {
+	parser := &LogParser{
+		options: options,
+	}
+
+	// Compile regex patterns based on enabled options
+	if err := parser.compileRegexes(); err != nil {
+		return nil, fmt.Errorf("failed to compile regex patterns: %w", err)
+	}
+
+	return parser, nil
+}
+
+// Parse extracts structured information from a raw log message using single regex
+func (p *LogParser) Parse(message string) (*LogEntry, error) {
+	entry := LogEntry{
+		Message: message,
+		Level:   slog.LevelInfo, // Default level
+	}
+
+	if p.masterRegex == nil {
+		return nil, fmt.Errorf("regex not compiled")
+	}
+
+	matches := p.masterRegex.FindStringSubmatch(strings.TrimSpace(message))
+	if matches == nil {
+		return nil, fmt.Errorf("failed to parse log format")
+	}
+
+	// Extract groups based on regex pattern:
+	// 1: timestamp, 2: thread, 3: source location, 4: function, 5: category, 6: level, 7: message
+	if len(matches) < 8 {
+		return nil, fmt.Errorf("insufficient regex groups: expected 8, got %d", len(matches))
+	}
+
+	// Parse timestamp
+	if matches[1] != "" {
+		// supports parsing time with/without microseconds
+		ts, err := time.Parse(time.RFC3339, matches[1])
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse timestamp: %w", err)
+		}
+		entry.Time = ts
+	}
+
+	// Parse thread
+	entry.Thread = matches[2]
+
+	// Parse source location and extract filename/line number
+	if matches[3] != "" {
+		entry.Source = matches[3]
+		if parts := strings.Split(matches[3], ":"); len(parts) >= 2 {
+			entry.Path = strings.TrimSpace(parts[0])
+			lineNum, err := strconv.Atoi(parts[len(parts)-1])
+			if err != nil {
+				return nil, fmt.Errorf("failed to parse line number: %w", err)
+			}
+			entry.LineNumber = lineNum
+			// Extract the filename from the full path
+			if idx := strings.LastIndex(entry.Path, "/"); idx != -1 {
+				entry.File = entry.Path[idx+1:]
+			} else {
+				entry.File = entry.Path
+			}
+		}
+	}
+
+	// Parse function name
+	entry.Function = matches[4]
+
+	// Parse category and level
+	entry.Category = matches[5]
+	if matches[6] != "" {
+		entry.Level = parseLogLevel(matches[6])
+	}
+
+	// Extract message
+	entry.Message = strings.TrimSpace(matches[7])
+
+	return &entry, nil
+}
+
+// compileRegexes builds and compiles a single masterRegex for parsing
+func (p *LogParser) compileRegexes() error {
+	pattern := "^"
+
+	// Time group (optional)
+	if p.options.LogTimestamps {
+		//TODO consider p.options.LogTimeMicros
+		pattern += `(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)\s+`
+	} else {
+		pattern += "()"
+	}
+
+	// Thread name group (optional)
+	if p.options.LogThreadNames {
+		pattern += `\[([^\]]+)\]\s+`
+	} else {
+		pattern += "()"
+	}
+
+	// Source location group (optional)
+	if p.options.LogSourceLocations {
+		pattern += `\[([^\]]+)\]\s+`
+	} else {
+		pattern += "()"
+	}
+
+	// Function name group (optional)
+	if p.options.LogSourceLocations {
+		pattern += `\[([^\]]+)\]\s+`
+	} else {
+		pattern += "()"
+	}
+
+	// Category and level group (optional)
+	if p.options.AlwaysPrintCategoryLevel {
+		pattern += `\[([^:]+):([^\]]+)\]\s+`
+	} else {
+		pattern += "()()"
+	}
+
+	// Message (everything remaining)
+	pattern += "(.+)$"
+
+	var err error
+	p.masterRegex, err = regexp.Compile(pattern)
+	if err != nil {
+		return fmt.Errorf("failed to compile master regex: %w", err)
+	}
+
+	return nil
+}
+
+// parseLogLevel converts string log level to slog.Level
+func parseLogLevel(levelStr string) slog.Level {
+	switch strings.ToLower(levelStr) {
+	case "trace":
+		return slog.LevelDebug - 4 // Custom trace level
+	case "debug":
+		return slog.LevelDebug
+	case "info":
+		return slog.LevelInfo
+	default:
+		return slog.LevelInfo
+	}
+}

utils/log_parser_test.go

@@ -0,0 +1,142 @@
+package utils
+
+import (
+	"fmt"
+	"github.com/stringintech/go-bitcoinkernel/kernel"
+	"testing"
+	"time"
+)
+
+func TestLogParserParse(t *testing.T) {
+	timeStr := "2025-03-19T12:14:55Z"
+	thread := "unknown"
+	filename := "context.cpp"
+	path := fmt.Sprintf("depend/bitcoin/src/kernel/%s", filename)
+	lineno := 20
+	function := "operator()"
+	category := "all"
+	level := "info"
+	msg := "Using the 'arm_shani(1way,2way)' SHA256 implementation"
+	logString := fmt.Sprintf("%s [%s] [%s:%d] [%s] [%s:%s] %s",
+		timeStr, thread, path, lineno, function, category, level, msg)
+
+	options := kernel.LoggingOptions{
+		LogTimestamps:            true,
+		LogTimeMicros:            false,
+		LogThreadNames:           true,
+		LogSourceLocations:       true,
+		AlwaysPrintCategoryLevel: true,
+	}
+
+	parser, err := NewLogParser(options)
+	if err != nil {
+		t.Fatalf("Failed to create log parser: %v", err)
+	}
+
+	// Parse the log string
+	entry, err := parser.Parse(logString)
+	if err != nil {
+		t.Fatalf("Parse error: %v", err)
+	}
+
+	expectedTime, _ := time.Parse(time.RFC3339, timeStr)
+	if !entry.Time.Equal(expectedTime) {
+		t.Errorf("Expected timestamp %v, got %v", expectedTime, entry.Time)
+	}
+
+	if entry.Thread != thread {
+		t.Errorf("Expected thread %s, got %s", thread, entry.Thread)
+	}
+
+	if entry.Path != path {
+		t.Errorf("Expected path %s, got %s", filename, entry.File)
+	}
+
+	if entry.File != filename {
+		t.Errorf("Expected filename %s, got %s", filename, entry.File)
+	}
+
+	if entry.LineNumber != lineno {
+		t.Errorf("Expected line number %d, got %d", lineno, entry.LineNumber)
+	}
+
+	if entry.Function != function {
+		t.Errorf("Expected function %s, got %s", function, entry.Function)
+	}
+
+	if entry.Category != category {
+		t.Errorf("Expected category %s, got %s", category, entry.Category)
+	}
+
+	expectedLevel := parseLogLevel(level)
+	if entry.Level != expectedLevel {
+		t.Errorf("Expected level %v, got %v", expectedLevel, entry.Level)
+	}
+
+	if entry.Message != msg {
+		t.Errorf("Expected message %s, got %s", msg, entry.Message)
+	}
+}
+
+// TestRegexCompilation tests regex compilation with different options
+func TestRegexCompilation(t *testing.T) {
+	testCases := []struct {
+		name    string
+		options kernel.LoggingOptions
+	}{
+		{
+			name: "no options",
+			options: kernel.LoggingOptions{
+				LogTimestamps:            false,
+				LogTimeMicros:            false,
+				LogThreadNames:           false,
+				LogSourceLocations:       false,
+				AlwaysPrintCategoryLevel: false,
+			},
+		},
+		{
+			name: "timestamps only",
+			options: kernel.LoggingOptions{
+				LogTimestamps:            true,
+				LogTimeMicros:            false,
+				LogThreadNames:           false,
+				LogSourceLocations:       false,
+				AlwaysPrintCategoryLevel: false,
+			},
+		},
+		{
+			name: "microsecond timestamps",
+			options: kernel.LoggingOptions{
+				LogTimestamps:            true,
+				LogTimeMicros:            true,
+				LogThreadNames:           false,
+				LogSourceLocations:       false,
+				AlwaysPrintCategoryLevel: false,
+			},
+		},
+		{
+			name: "all options",
+			options: kernel.LoggingOptions{
+				LogTimestamps:            true,
+				LogTimeMicros:            true,
+				LogThreadNames:           true,
+				LogSourceLocations:       true,
+				AlwaysPrintCategoryLevel: true,
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			parser := &LogParser{options: tc.options}
+			err := parser.compileRegexes()
+			if err != nil {
+				t.Errorf("Failed to compile regexes for %s: %v", tc.name, err)
+			}
+
+			if parser.masterRegex == nil {
+				t.Errorf("Expected regex to be compiled for %s", tc.name)
+			}
+		})
+	}
+}