fix(vm): uptime update status field (#2304)

Add .status.stats.lastStartTime to VirtualMachine and use it for the Uptime printable column.

lastStartTime is calculated from the VM Running condition. As a temporary compatibility fallback, if kvvmi.status.phaseTransitionTimestamps contains the Running phase timestamp and it differs from the VM condition timestamp by more than 10 minutes, the controller uses the VMI timestamp instead.

The fallback is marked with TODO and should be removed after 2026-10-29.

---------

Signed-off-by: Daniil Antoshin <daniil.antoshin@flant.com>

Author: danilrwx

api/core/v1alpha2/virtual_machine.go

@@ -41,7 +41,7 @@ const (
 // +kubebuilder:subresource:status
 // +kubebuilder:resource:categories={all,virtualization},scope=Namespaced,shortName={vm},singular=virtualmachine
 // +kubebuilder:printcolumn:name="Phase",type="string",JSONPath=".status.phase",description="The phase of the virtual machine."
-// +kubebuilder:printcolumn:name="Uptime",type="date",JSONPath=".status.conditions[?(@.reason==\"Running\")].lastTransitionTime",description="Time since the virtual machine started running."
+// +kubebuilder:printcolumn:name="Uptime",type="date",JSONPath=".status.stats.lastStartTime",description="Time since the virtual machine started running."
 // +kubebuilder:printcolumn:name="Cores",priority=1,type="string",JSONPath=".spec.cpu.cores",description="The number of cores of the virtual machine."
 // +kubebuilder:printcolumn:name="CoreFraction",priority=1,type="string",JSONPath=".spec.cpu.coreFraction",description="Virtual machine core fraction. The range of available values is set in the `sizePolicy` parameter of the VirtualMachineClass; if it is not set, use values within the 1–100% range."
 // +kubebuilder:printcolumn:name="Memory",priority=1,type="string",JSONPath=".spec.memory.size",description="The amount of memory of the virtual machine."
@@ -330,6 +330,8 @@ type VirtualMachineStats struct {
 	PhasesTransitions []VirtualMachinePhaseTransitionTimestamp `json:"phasesTransitions,omitempty"`
 	// Launch information.
 	LaunchTimeDuration VirtualMachineLaunchTimeDuration `json:"launchTimeDuration,omitempty"`
+	// LastStartTime is the timestamp when the virtual machine last started running.
+	LastStartTime *metav1.Time `json:"lastStartTime,omitempty"`
 }
 
 // VirtualMachinePhaseTransitionTimestamp gives a timestamp in relation to when a phase is set on a vm.

api/core/v1alpha2/zz_generated.deepcopy.go

@@ -706,6 +706,8 @@ spec:
                           description: Время ожидания запуска виртуальной машины. `starting` -> `running`.
                         guestOSAgentStarting:
                           description: Время ожидания запуска guestOsAgent. `running` -> `running` с guestOSAgent."
+                    lastStartTime:
+                      description: Время последнего запуска виртуальной машины.
                 observedGeneration:
                   description: |
                     Поколение ресурса, которое в последний раз обрабатывалось контроллером.

crds/doc-ru-virtualmachines.yaml

@@ -1197,6 +1197,11 @@ spec:
                           description: Waiting time for the guestOsAgent to start. `running` -> `running` with guestOSAgent.
                           nullable: true
                           type: string
+                    lastStartTime:
+                      description: Time when the virtual machine last started running.
+                      format: date-time
+                      nullable: true
+                      type: string
                 conditions:
                   description: State of the running virtual machine.
                   items:
@@ -1423,7 +1428,7 @@ spec:
           name: Phase
           type: string
         - description: Time since the virtual machine started running.
-          jsonPath: '.status.conditions[?(@.reason=="Running")].lastTransitionTime'
+          jsonPath: .status.stats.lastStartTime
           name: Uptime
           type: date
         - description: Real number of the virtual machine cores.

crds/virtualmachines.yaml

@@ -34,9 +34,14 @@ import (
 	"github.com/deckhouse/virtualization-controller/pkg/controller/kvbuilder"
 	"github.com/deckhouse/virtualization-controller/pkg/controller/vm/internal/state"
 	"github.com/deckhouse/virtualization/api/core/v1alpha2"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2/vmcondition"
 )
 
-const nameStatisticHandler = "StatisticHandler"
+const (
+	nameStatisticHandler = "StatisticHandler"
+	// TODO: Remove this fallback after 2026-10-29.
+	lastStartTimePhaseTransitionMaxDiff = 10 * time.Minute
+)
 
 func NewStatisticHandler(client client.Client) *StatisticHandler {
 	return &StatisticHandler{client: client}
@@ -367,6 +372,52 @@ func (h *StatisticHandler) syncStats(current, changed *v1alpha2.VirtualMachine,
 
 	stats.LaunchTimeDuration = launchTimeDuration
 	changed.Status.Stats = &stats
+	syncLastStartTime(changed, kvvmi)
+}
+
+func syncLastStartTime(vm *v1alpha2.VirtualMachine, kvvmi *virtv1.VirtualMachineInstance) {
+	running := getRunningCondition(vm)
+	if running == nil || running.Status != metav1.ConditionTrue {
+		if vm.Status.Stats != nil {
+			vm.Status.Stats.LastStartTime = nil
+		}
+		return
+	}
+
+	kvvmiRunningAt := getKVVMIRunningPhaseTransitionTimestamp(kvvmi)
+	if kvvmiRunningAt != nil && running.LastTransitionTime.Sub(kvvmiRunningAt.Time).Abs() > lastStartTimePhaseTransitionMaxDiff {
+		running.LastTransitionTime = *kvvmiRunningAt.DeepCopy()
+	}
+
+	if vm.Status.Stats == nil {
+		vm.Status.Stats = &v1alpha2.VirtualMachineStats{}
+	}
+	vm.Status.Stats.LastStartTime = running.LastTransitionTime.DeepCopy()
+}
+
+func getRunningCondition(vm *v1alpha2.VirtualMachine) *metav1.Condition {
+	for i := range vm.Status.Conditions {
+		if vm.Status.Conditions[i].Type == vmcondition.TypeRunning.String() {
+			return &vm.Status.Conditions[i]
+		}
+	}
+
+	return nil
+}
+
+func getKVVMIRunningPhaseTransitionTimestamp(kvvmi *virtv1.VirtualMachineInstance) *metav1.Time {
+	if kvvmi == nil {
+		return nil
+	}
+
+	for i := len(kvvmi.Status.PhaseTransitionTimestamps) - 1; i >= 0; i-- {
+		transition := kvvmi.Status.PhaseTransitionTimestamps[i]
+		if transition.Phase == virtv1.Running {
+			return &transition.PhaseTransitionTimestamp
+		}
+	}
+
+	return nil
 }
 
 func osInfoIsEmpty(info virtv1.VirtualMachineInstanceGuestOSInfo) bool {

images/virtualization-artifact/pkg/controller/vm/internal/statistic.go

@@ -18,11 +18,13 @@ package internal
 
 import (
 	"context"
+	"time"
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/utils/ptr"
 	virtv1 "kubevirt.io/api/core/v1"
@@ -34,6 +36,7 @@ import (
 	"github.com/deckhouse/virtualization-controller/pkg/controller/reconciler"
 	"github.com/deckhouse/virtualization-controller/pkg/controller/vm/internal/state"
 	"github.com/deckhouse/virtualization/api/core/v1alpha2"
+	"github.com/deckhouse/virtualization/api/core/v1alpha2/vmcondition"
 )
 
 var _ = Describe("TestStatisticHandler", func() {
@@ -309,3 +312,112 @@ var _ = Describe("TestStatisticHandler", func() {
 		),
 	)
 })
+
+var _ = Describe("StatisticHandler", func() {
+	Describe("syncLastStartTime", func() {
+		It("sets lastStartTime from the Running condition last transition time", func() {
+			transitionTime := metav1.NewTime(time.Date(2026, 4, 24, 12, 0, 0, 0, time.UTC))
+			vm := newVMWithRunningCondition(transitionTime)
+
+			syncLastStartTime(vm, nil)
+
+			Expect(vm.Status.Stats).NotTo(BeNil())
+			Expect(vm.Status.Stats.LastStartTime).NotTo(BeNil())
+			Expect(vm.Status.Stats.LastStartTime.Time).To(Equal(transitionTime.Time))
+		})
+
+		It("sets lastStartTime from the VMI Running phase transition if it differs from the Running condition transition by more than ten minutes", func() {
+			conditionTime := metav1.NewTime(time.Date(2026, 4, 24, 12, 20, 0, 0, time.UTC))
+			vmiRunningTime := metav1.NewTime(time.Date(2026, 4, 24, 12, 0, 0, 0, time.UTC))
+			vm := newVMWithRunningCondition(conditionTime)
+			kvvmi := newKVVMIWithRunningPhaseTransition(vmiRunningTime)
+
+			syncLastStartTime(vm, kvvmi)
+
+			Expect(vm.Status.Stats).NotTo(BeNil())
+			Expect(vm.Status.Stats.LastStartTime).NotTo(BeNil())
+			Expect(vm.Status.Stats.LastStartTime.Time).To(Equal(vmiRunningTime.Time))
+			Expect(vm.Status.Conditions[0].LastTransitionTime.Time).To(Equal(vmiRunningTime.Time))
+		})
+
+		It("sets lastStartTime from the VMI Running phase transition if it is newer than the Running condition transition by more than ten minutes", func() {
+			conditionTime := metav1.NewTime(time.Date(2026, 4, 24, 12, 0, 0, 0, time.UTC))
+			vmiRunningTime := metav1.NewTime(time.Date(2026, 4, 24, 12, 20, 0, 0, time.UTC))
+			vm := newVMWithRunningCondition(conditionTime)
+			kvvmi := newKVVMIWithRunningPhaseTransition(vmiRunningTime)
+
+			syncLastStartTime(vm, kvvmi)
+
+			Expect(vm.Status.Stats).NotTo(BeNil())
+			Expect(vm.Status.Stats.LastStartTime).NotTo(BeNil())
+			Expect(vm.Status.Stats.LastStartTime.Time).To(Equal(vmiRunningTime.Time))
+			Expect(vm.Status.Conditions[0].LastTransitionTime.Time).To(Equal(vmiRunningTime.Time))
+		})
+
+		It("sets lastStartTime from the Running condition when the VMI Running phase transition does not differ by more than ten minutes", func() {
+			conditionTime := metav1.NewTime(time.Date(2026, 4, 24, 12, 9, 0, 0, time.UTC))
+			vmiRunningTime := metav1.NewTime(time.Date(2026, 4, 24, 12, 0, 0, 0, time.UTC))
+			vm := newVMWithRunningCondition(conditionTime)
+			kvvmi := newKVVMIWithRunningPhaseTransition(vmiRunningTime)
+
+			syncLastStartTime(vm, kvvmi)
+
+			Expect(vm.Status.Stats).NotTo(BeNil())
+			Expect(vm.Status.Stats.LastStartTime).NotTo(BeNil())
+			Expect(vm.Status.Stats.LastStartTime.Time).To(Equal(conditionTime.Time))
+			Expect(vm.Status.Conditions[0].LastTransitionTime.Time).To(Equal(conditionTime.Time))
+		})
+
+		DescribeTable("clears lastStartTime when the VM is not running",
+			func(conditions []metav1.Condition) {
+				lastStartTime := metav1.NewTime(time.Date(2026, 4, 24, 12, 0, 0, 0, time.UTC))
+				vm := &v1alpha2.VirtualMachine{
+					Status: v1alpha2.VirtualMachineStatus{
+						Stats:      &v1alpha2.VirtualMachineStats{LastStartTime: &lastStartTime},
+						Conditions: conditions,
+					},
+				}
+
+				syncLastStartTime(vm, nil)
+
+				Expect(vm.Status.Stats).NotTo(BeNil())
+				Expect(vm.Status.Stats.LastStartTime).To(BeNil())
+			},
+			Entry("without the Running condition", nil),
+			Entry("with the Running condition set to False", []metav1.Condition{
+				{
+					Type:               vmcondition.TypeRunning.String(),
+					Status:             metav1.ConditionFalse,
+					LastTransitionTime: metav1.NewTime(time.Date(2026, 4, 24, 12, 0, 0, 0, time.UTC)),
+				},
+			}),
+		)
+	})
+})
+
+func newVMWithRunningCondition(transitionTime metav1.Time) *v1alpha2.VirtualMachine {
+	return &v1alpha2.VirtualMachine{
+		Status: v1alpha2.VirtualMachineStatus{
+			Conditions: []metav1.Condition{
+				{
+					Type:               vmcondition.TypeRunning.String(),
+					Status:             metav1.ConditionTrue,
+					LastTransitionTime: transitionTime,
+				},
+			},
+		},
+	}
+}
+
+func newKVVMIWithRunningPhaseTransition(transitionTime metav1.Time) *virtv1.VirtualMachineInstance {
+	return &virtv1.VirtualMachineInstance{
+		Status: virtv1.VirtualMachineInstanceStatus{
+			PhaseTransitionTimestamps: []virtv1.VirtualMachineInstancePhaseTransitionTimestamp{
+				{
+					Phase:                    virtv1.Running,
+					PhaseTransitionTimestamp: transitionTime,
+				},
+			},
+		},
+	}
+}