Add events section

Author: ilyario

README.md

@@ -63,15 +63,6 @@ cd dataflow-web/web && npm install && npm run dev
 
 Open http://localhost:8080 (option 1) or http://localhost:5173 (option 2). Cluster access requires `KUBECONFIG` or in-cluster config.
 
-## Deploying to cluster (Helm)
+## Deploying to cluster
 
-With GUI enabled, set the dataflow-web image:
-
-```bash
-helm upgrade --install dataflow-operator ./helm-charts/dataflow-operator \
-  --set image.repository=... \
-  --set image.tag=... \
-  --set gui.enabled=true \
-  --set gui.image.repository=dataflow-web \
-  --set gui.image.tag=local
-```
+Deploy via Helm with `gui.enabled=true`. See [Web GUI documentation](../docs/docs/en/gui.md) for configuration and deployment details.

internal/gui/api_handler.go

@@ -22,6 +22,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"sort"
 	"strconv"
 	"strings"
 
@@ -83,6 +84,8 @@ func (h *APIHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		h.handleStatus(w, r, filteredParts[1:])
 	case filteredParts[0] == "namespaces":
 		h.handleNamespaces(w, r)
+	case filteredParts[0] == "events":
+		h.handleEvents(w, r)
 	default:
 		http.Error(w, "Not found", http.StatusNotFound)
 	}
@@ -421,6 +424,45 @@ func (h *APIHandler) handleStatus(w http.ResponseWriter, r *http.Request, parts
 	json.NewEncoder(w).Encode(status)
 }
 
+func (h *APIHandler) handleEvents(w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	namespace := r.URL.Query().Get("namespace")
+	if namespace == "" {
+		namespace = "default"
+	}
+	name := r.URL.Query().Get("name")
+
+	fieldSelector := "involvedObject.kind=DataFlow"
+	if name != "" {
+		fieldSelector += ",involvedObject.name=" + name
+	}
+
+	events, err := h.server.k8sClient.CoreV1().Events(namespace).List(r.Context(), metav1.ListOptions{
+		FieldSelector: fieldSelector,
+	})
+	if err != nil {
+		h.server.logger.Error(err, "Failed to list events")
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	items := events.Items
+	sort.Slice(items, func(i, j int) bool {
+		return items[j].LastTimestamp.Before(&items[i].LastTimestamp)
+	})
+
+	const maxEvents = 100
+	if len(items) > maxEvents {
+		items = items[:maxEvents]
+	}
+
+	json.NewEncoder(w).Encode(items)
+}
+
 func (h *APIHandler) handleNamespaces(w http.ResponseWriter, r *http.Request) {
 	if r.Method != "GET" {
 		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)

internal/gui/api_handler_test.go

@@ -19,11 +19,14 @@ import (
 	"net/http/httptest"
 	"strings"
 	"testing"
+	"time"
 
+	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
+	k8sfake "k8s.io/client-go/kubernetes/fake"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/fake"
@@ -333,6 +336,119 @@ go_goroutines 5
 	}
 }
 
+func TestAPIHandler_Events_AllInNamespace(t *testing.T) {
+	now := metav1.NewTime(time.Now())
+	ev1 := &corev1.Event{
+		ObjectMeta: metav1.ObjectMeta{Name: "ev1", Namespace: "default"},
+		Type:       "Normal",
+		Reason:     "ConfigMapCreated",
+		Message:    "Created ConfigMap test-cm",
+		InvolvedObject: corev1.ObjectReference{
+			Kind:      "DataFlow",
+			Name:      "my-flow",
+			Namespace: "default",
+		},
+		LastTimestamp: now,
+	}
+	fakeK8s := k8sfake.NewSimpleClientset(ev1)
+
+	scheme := runtime.NewScheme()
+	utilruntime.Must(clientgoscheme.AddToScheme(scheme))
+	utilruntime.Must(dataflowv1.AddToScheme(scheme))
+	fakeClient := fake.NewClientBuilder().WithScheme(scheme).Build()
+
+	server := &Server{
+		client:    fakeClient,
+		k8sClient: fakeK8s,
+		logger:    ctrl.Log.WithName("test"),
+	}
+	handler := NewAPIHandler(server)
+
+	req := httptest.NewRequest("GET", "/events?namespace=default", nil)
+	w := httptest.NewRecorder()
+	handler.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+
+	var events []corev1.Event
+	if err := json.NewDecoder(w.Body).Decode(&events); err != nil {
+		t.Fatalf("Failed to decode: %v", err)
+	}
+	if len(events) != 1 {
+		t.Errorf("Expected 1 event, got %d", len(events))
+	}
+	if events[0].Reason != "ConfigMapCreated" {
+		t.Errorf("Expected reason ConfigMapCreated, got %s", events[0].Reason)
+	}
+}
+
+func TestAPIHandler_Events_FilterByManifest(t *testing.T) {
+	now := metav1.NewTime(time.Now())
+	ev1 := &corev1.Event{
+		ObjectMeta: metav1.ObjectMeta{Name: "ev1", Namespace: "default"},
+		Type:       "Normal",
+		Reason:     "ConfigMapCreated",
+		Message:    "Created ConfigMap",
+		InvolvedObject: corev1.ObjectReference{
+			Kind: "DataFlow", Name: "flow-a", Namespace: "default",
+		},
+		LastTimestamp: now,
+	}
+	ev2 := &corev1.Event{
+		ObjectMeta: metav1.ObjectMeta{Name: "ev2", Namespace: "default"},
+		Type:       "Warning",
+		Reason:     "DeploymentFailed",
+		Message:    "Failed",
+		InvolvedObject: corev1.ObjectReference{
+			Kind: "DataFlow", Name: "flow-b", Namespace: "default",
+		},
+		LastTimestamp: now,
+	}
+	fakeK8s := k8sfake.NewSimpleClientset(ev1, ev2)
+
+	scheme := runtime.NewScheme()
+	utilruntime.Must(clientgoscheme.AddToScheme(scheme))
+	utilruntime.Must(dataflowv1.AddToScheme(scheme))
+	fakeClient := fake.NewClientBuilder().WithScheme(scheme).Build()
+
+	server := &Server{
+		client:    fakeClient,
+		k8sClient: fakeK8s,
+		logger:    ctrl.Log.WithName("test"),
+	}
+	handler := NewAPIHandler(server)
+
+	req := httptest.NewRequest("GET", "/events?namespace=default&name=flow-a", nil)
+	w := httptest.NewRecorder()
+	handler.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+
+	var events []corev1.Event
+	if err := json.NewDecoder(w.Body).Decode(&events); err != nil {
+		t.Fatalf("Failed to decode: %v", err)
+	}
+	// Fake clientset may not filter by field selector; at minimum we get valid response
+	if len(events) == 0 {
+		t.Errorf("Expected at least 1 event, got 0")
+	}
+	// If filtering works, we get only flow-a; otherwise we may get both
+	foundFlowA := false
+	for _, e := range events {
+		if e.InvolvedObject.Name == "flow-a" {
+			foundFlowA = true
+			break
+		}
+	}
+	if !foundFlowA {
+		t.Errorf("Expected at least one event for flow-a, got %v", events)
+	}
+}
+
 // TestScannerReadsLongLogLine verifies that a scanner with an increased buffer
 // reads lines longer than 64 KB without "token too long" error.
 func TestScannerReadsLongLogLine(t *testing.T) {

web/src/App.vue

@@ -8,6 +8,7 @@
           <router-link to="/manifests">{{ t('nav.manifests') }}</router-link>
           <router-link to="/logs">{{ t('nav.logs') }}</router-link>
           <router-link to="/metrics">{{ t('nav.metrics') }}</router-link>
+          <router-link to="/events">{{ t('nav.events') }}</router-link>
         </nav>
         <div class="header-controls">
           <select

web/src/api/client.js

@@ -90,3 +90,9 @@ export async function getMetrics(namespace, name) {
     `/metrics?namespace=${encodeURIComponent(namespace)}&name=${encodeURIComponent(name)}`
   )
 }
+
+export async function getEvents(namespace, name = null) {
+  const params = new URLSearchParams({ namespace })
+  if (name) params.set('name', name)
+  return request(`/events?${params.toString()}`)
+}

web/src/api/client.test.js

@@ -8,6 +8,7 @@ import {
   deleteDataFlow,
   getLogs,
   getStatus,
+  getEvents,
 } from './client'
 
 describe('API client', () => {
@@ -93,6 +94,26 @@ describe('API client', () => {
     expect(result.processedCount).toBe(10)
   })
 
+  it('getEvents returns all events when name is null', async () => {
+    const events = [{ type: 'Normal', reason: 'ConfigMapCreated', message: 'Created ConfigMap' }]
+    fetch.mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(events) })
+    const result = await getEvents('default')
+    expect(fetch).toHaveBeenCalledWith(
+      expect.stringMatching(/\?namespace=default$/),
+      expect.any(Object)
+    )
+    expect(result).toEqual(events)
+  })
+
+  it('getEvents adds name param when filtering by manifest', async () => {
+    fetch.mockResolvedValueOnce({ ok: true, json: () => Promise.resolve([]) })
+    await getEvents('default', 'my-dataflow')
+    expect(fetch).toHaveBeenCalledWith(
+      expect.stringMatching(/name=my-dataflow/),
+      expect.any(Object)
+    )
+  })
+
   it('throws on non-ok response', async () => {
     fetch.mockResolvedValueOnce({ ok: false, text: () => Promise.resolve('Not found') })
     await expect(getNamespaces()).rejects.toThrow()

web/src/locales/en.js

@@ -8,6 +8,7 @@ export default {
     manifests: 'Manifests',
     logs: 'Logs',
     metrics: 'Metrics',
+    events: 'Events',
   },
   theme: {
     light: 'Light theme',
@@ -66,6 +67,22 @@ export default {
     copied: 'Logs copied',
     selectDataflow: 'Select DataFlow',
   },
+  events: {
+    title: 'Kubernetes Events',
+    filterAll: 'All DataFlow events',
+    filterByManifest: 'Filter by manifest',
+    selectManifest: 'Select manifest',
+    loading: 'Loading events...',
+    empty: 'No events',
+    emptyFiltered: 'No events for this manifest',
+    refresh: 'Refresh',
+    type: 'Type',
+    reason: 'Reason',
+    message: 'Message',
+    object: 'Object',
+    time: 'Time',
+    count: 'Count',
+  },
   metrics: {
     title: 'Metrics and processing status',
     selectDataflow: 'Select DataFlow',

web/src/locales/ru.js

@@ -8,6 +8,7 @@ export default {
     manifests: 'Манифесты',
     logs: 'Логи',
     metrics: 'Метрики',
+    events: 'События',
   },
   theme: {
     light: 'Светлая тема',
@@ -66,6 +67,22 @@ export default {
     copied: 'Логи скопированы',
     selectDataflow: 'Выберите DataFlow',
   },
+  events: {
+    title: 'События Kubernetes',
+    filterAll: 'Все события DataFlow',
+    filterByManifest: 'Фильтр по манифесту',
+    selectManifest: 'Выберите манифест',
+    loading: 'Загрузка событий...',
+    empty: 'Нет событий',
+    emptyFiltered: 'Нет событий для этого манифеста',
+    refresh: 'Обновить',
+    type: 'Тип',
+    reason: 'Причина',
+    message: 'Сообщение',
+    object: 'Объект',
+    time: 'Время',
+    count: 'Кол-во',
+  },
   metrics: {
     title: 'Метрики и статус обработки',
     selectDataflow: 'Выберите DataFlow',

web/src/router/index.js

@@ -26,6 +26,12 @@ const routes = [
     component: () => import('../views/MetricsView.vue'),
     meta: { titleKey: 'nav.metrics' },
   },
+  {
+    path: '/events',
+    name: 'events',
+    component: () => import('../views/EventsView.vue'),
+    meta: { titleKey: 'nav.events' },
+  },
 ]
 
 const router = createRouter({