feat(parser): lenovo xcc warnings and redfish logs - v1.1

internal/collector/redfish_logentries.go

@@ -50,11 +50,15 @@ func (c *RedfishConnector) collectRedfishLogEntries(ctx context.Context, client
 	}
 
 	for _, systemPath := range systemPaths {
-		collectFrom(joinPath(systemPath, "/LogServices"), isHardwareLogService)
+		for _, logServicesPath := range c.redfishLinkedCollectionPaths(ctx, client, req, baseURL, systemPath, "LogServices") {
+			collectFrom(logServicesPath, isHardwareLogService)
+		}
 	}
 	// Managers hold the IPMI SEL on AMI/MSI BMCs — include only the "SEL" service.
 	for _, managerPath := range managerPaths {
-		collectFrom(joinPath(managerPath, "/LogServices"), isManagerSELService)
+		for _, logServicesPath := range c.redfishLinkedCollectionPaths(ctx, client, req, baseURL, managerPath, "LogServices") {
+			collectFrom(logServicesPath, isManagerSELService)
+		}
 	}
 
 	if len(out) > 0 {
@@ -63,6 +67,42 @@ func (c *RedfishConnector) collectRedfishLogEntries(ctx context.Context, client
 	return out
 }
 
+func (c *RedfishConnector) redfishLinkedCollectionPaths(
+	ctx context.Context,
+	client *http.Client,
+	req Request,
+	baseURL, resourcePath, linkKey string,
+) []string {
+	resourcePath = normalizeRedfishPath(resourcePath)
+	if resourcePath == "" || strings.TrimSpace(linkKey) == "" {
+		return nil
+	}
+
+	seen := make(map[string]struct{}, 2)
+	var out []string
+	add := func(path string) {
+		path = normalizeRedfishPath(path)
+		if path == "" {
+			return
+		}
+		if _, ok := seen[path]; ok {
+			return
+		}
+		seen[path] = struct{}{}
+		out = append(out, path)
+	}
+
+	add(joinPath(resourcePath, "/"+strings.TrimSpace(linkKey)))
+
+	resourceDoc, err := c.getJSON(ctx, client, req, baseURL, resourcePath)
+	if err == nil {
+		if linked := redfishLinkedPath(resourceDoc, linkKey); linked != "" {
+			add(linked)
+		}
+	}
+	return out
+}
+
 // fetchRedfishLogEntriesWithPaging fetches entries from a LogEntry collection,
 // following nextLink pages. Stops early when entries older than cutoff are encountered
 // (assumes BMC returns entries newest-first, which is typical).
@@ -182,7 +222,7 @@ func redfishLogServiceEntriesPath(svc map[string]interface{}) string {
 // Audit, authentication, and session events are excluded.
 func isHardwareLogEntry(entry map[string]interface{}) bool {
 	entryType := strings.TrimSpace(asString(entry["EntryType"]))
-	if strings.EqualFold(entryType, "Oem") {
+	if strings.EqualFold(entryType, "Oem") && !strings.EqualFold(strings.TrimSpace(asString(entry["OemRecordFormat"])), "Lenovo") {
 		return false
 	}
 
@@ -362,6 +402,9 @@ func parseIPMIDumpKV(message string) map[string]string {
 // AMI/MSI BMCs often set Severity="OK" on all SEL records regardless of content,
 // so we fall back to inferring severity from SensorType when the explicit field is unhelpful.
 func redfishLogEntrySeverity(entry map[string]interface{}) models.Severity {
+	if redfishLogEntryLooksLikeWarning(entry) {
+		return models.SeverityWarning
+	}
 	// Newer Redfish uses MessageSeverity; older uses Severity.
 	raw := strings.ToLower(firstNonEmpty(
 		strings.TrimSpace(asString(entry["MessageSeverity"])),
@@ -380,6 +423,16 @@ func redfishLogEntrySeverity(entry map[string]interface{}) models.Severity {
 	}
 }
 
+func redfishLogEntryLooksLikeWarning(entry map[string]interface{}) bool {
+	joined := strings.ToLower(strings.TrimSpace(strings.Join([]string{
+		asString(entry["Message"]),
+		asString(entry["Name"]),
+		asString(entry["SensorType"]),
+		asString(entry["EntryCode"]),
+	}, " ")))
+	return strings.Contains(joined, "unqualified dimm")
+}
+
 // redfishSeverityFromSensorType infers event severity from the IPMI/Redfish SensorType string.
 func redfishSeverityFromSensorType(sensorType string) models.Severity {
 	switch strings.ToLower(sensorType) {

internal/collector/redfish_logentries_test.go

@@ -0,0 +1,125 @@
+package collector
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"git.mchus.pro/mchus/logpile/internal/models"
+)
+
+func TestCollectRedfishLogEntries_UsesLinkedManagerLogServicesPath(t *testing.T) {
+	mux := http.NewServeMux()
+	register := func(path string, payload interface{}) {
+		mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			_ = json.NewEncoder(w).Encode(payload)
+		})
+	}
+
+	register("/redfish/v1/Managers/1", map[string]interface{}{
+		"Id": "1",
+		"LogServices": map[string]interface{}{
+			"@odata.id": "/redfish/v1/Systems/1/LogServices",
+		},
+	})
+	register("/redfish/v1/Systems/1/LogServices", map[string]interface{}{
+		"Members": []map[string]string{
+			{"@odata.id": "/redfish/v1/Systems/1/LogServices/SEL"},
+		},
+	})
+	register("/redfish/v1/Systems/1/LogServices/SEL", map[string]interface{}{
+		"Id": "SEL",
+		"Entries": map[string]interface{}{
+			"@odata.id": "/redfish/v1/Systems/1/LogServices/SEL/Entries",
+		},
+	})
+	register("/redfish/v1/Systems/1/LogServices/SEL/Entries", map[string]interface{}{
+		"Members": []map[string]string{
+			{"@odata.id": "/redfish/v1/Systems/1/LogServices/SEL/Entries/1"},
+		},
+	})
+	register("/redfish/v1/Systems/1/LogServices/SEL/Entries/1", map[string]interface{}{
+		"Id":              "1",
+		"Created":         time.Now().UTC().Format(time.RFC3339),
+		"Message":         "System found Unqualified DIMM in slot DIMM A1",
+		"MessageSeverity": "OK",
+		"SensorType":      "Memory",
+		"EntryType":       "Event",
+	})
+
+	ts := httptest.NewServer(mux)
+	defer ts.Close()
+
+	c := NewRedfishConnector()
+	got := c.collectRedfishLogEntries(context.Background(), ts.Client(), Request{
+		Host:     ts.URL,
+		Port:     443,
+		Protocol: "redfish",
+		Username: "admin",
+		AuthType: "password",
+		Password: "secret",
+		TLSMode:  "strict",
+	}, ts.URL, nil, []string{"/redfish/v1/Managers/1"})
+
+	if len(got) != 1 {
+		t.Fatalf("expected 1 collected log entry, got %d", len(got))
+	}
+	if got[0]["Message"] != "System found Unqualified DIMM in slot DIMM A1" {
+		t.Fatalf("unexpected collected message: %#v", got[0]["Message"])
+	}
+}
+
+func TestParseRedfishLogEntries_UnqualifiedDIMMBecomesWarning(t *testing.T) {
+	rawPayloads := map[string]any{
+		"redfish_log_entries": []any{
+			map[string]any{
+				"Id":              "sel-1",
+				"Created":         "2026-04-13T12:00:00Z",
+				"Message":         "System found Unqualified DIMM in slot DIMM A1",
+				"MessageSeverity": "OK",
+				"SensorType":      "Memory",
+				"EntryType":       "Event",
+			},
+		},
+	}
+
+	events := parseRedfishLogEntries(rawPayloads, time.Date(2026, 4, 13, 12, 30, 0, 0, time.UTC))
+	if len(events) != 1 {
+		t.Fatalf("expected 1 event, got %d", len(events))
+	}
+	if events[0].Severity != models.SeverityWarning {
+		t.Fatalf("expected warning severity, got %q", events[0].Severity)
+	}
+	if events[0].Description != "System found Unqualified DIMM in slot DIMM A1" {
+		t.Fatalf("unexpected description: %q", events[0].Description)
+	}
+}
+
+func TestParseRedfishLogEntries_LenovoOEMEntryIsKept(t *testing.T) {
+	rawPayloads := map[string]any{
+		"redfish_log_entries": []any{
+			map[string]any{
+				"Id":              "plat-55",
+				"Created":         "2026-04-13T12:00:00Z",
+				"Message":         "DIMM A1 is unqualified",
+				"MessageSeverity": "Warning",
+				"SensorType":      "Memory",
+				"EntryType":       "Oem",
+				"OemRecordFormat": "Lenovo",
+				"EntryCode":       "Assert",
+			},
+		},
+	}
+
+	events := parseRedfishLogEntries(rawPayloads, time.Date(2026, 4, 13, 12, 30, 0, 0, time.UTC))
+	if len(events) != 1 {
+		t.Fatalf("expected 1 Lenovo OEM event, got %d", len(events))
+	}
+	if events[0].Severity != models.SeverityWarning {
+		t.Fatalf("expected warning severity, got %q", events[0].Severity)
+	}
+}