chore: address event-log v2 review nits

- tell the operator how to recover when the runtime event version
  conflicts: the value is fixed for the boot, so a new app-compose
  `event_log_version` needs a CVM restart
- drop the two private `is_v1` helpers in favour of the existing
  `EventLogVersion::is_v1`, which AppCompose already uses
- document why the runtime event lock waits without a timeout
- explain in the Go SDK that a zero `Version` means V1, since the field
  is omitted from the wire format for V1 events

Author: kvinwang

dstack/cc-eventlog/src/runtime_events.rs

@@ -33,15 +33,11 @@ pub struct RuntimeEvent {
     #[serde(with = "base64")]
     pub payload: Vec<u8>,
     /// Event log version
-    #[serde(default, skip_serializing_if = "is_v1")]
+    #[serde(default, skip_serializing_if = "EventLogVersion::is_v1")]
     #[codec(skip)]
     pub version: EventLogVersion,
 }
 
-fn is_v1(version: &EventLogVersion) -> bool {
-    matches!(version, EventLogVersion::V1)
-}
-
 impl RuntimeEvent {
     pub fn new(event: String, payload: Vec<u8>, version: EventLogVersion) -> Self {
         Self {

dstack/cc-eventlog/src/tdx.rs

@@ -49,7 +49,7 @@ pub struct TdxEvent {
     /// Skipped by scale codec for binary compat with legacy attestations
     /// (which only ever contain V1 events).
     /// Serde skips serialization when V1 so existing JSON outputs stay clean.
-    #[serde(default, skip_serializing_if = "is_v1")]
+    #[serde(default, skip_serializing_if = "EventLogVersion::is_v1")]
     #[codec(skip)]
     pub version: EventLogVersion,
 
@@ -64,10 +64,6 @@ pub struct TdxEvent {
     pub preimage: Option<String>,
 }
 
-fn is_v1(v: &EventLogVersion) -> bool {
-    matches!(v, EventLogVersion::V1)
-}
-
 impl TdxEvent {
     pub fn new(imr: u32, event_type: u32, event: String, event_payload: Vec<u8>) -> Self {
         Self {

dstack/dstack-attest/src/lib.rs

@@ -23,6 +23,15 @@ const RUNTIME_EVENT_DIR: &str = "/run/log/dstack";
 const RUNTIME_EVENT_VERSION_FILE: &str = "/run/log/dstack/runtime_event_version";
 const RUNTIME_EVENT_LOCK_FILE: &str = "/run/log/dstack/runtime_event.lock";
 
+/// Acquire the system-wide runtime event lock, blocking until it is available.
+///
+/// The wait is deliberately unbounded. The lock serializes the event-log append
+/// with the measurement-register extension, and that ordering is what makes
+/// replay reproduce the quoted register value. Proceeding after a timeout would
+/// break the invariant, and failing after one would abort a boot that is merely
+/// slow, so waiting is the only safe option. A holder that dies releases the
+/// lock automatically (flock is dropped when the file descriptor closes), which
+/// leaves a live but wedged holder as the sole way to block emission.
 fn runtime_event_lock() -> anyhow::Result<fs_err::File> {
     fs_err::create_dir_all(RUNTIME_EVENT_DIR)
         .context("failed to create runtime event log directory")?;
@@ -60,7 +69,9 @@ fn set_runtime_event_version_file(
         Ok(configured) => {
             anyhow::ensure!(
                 configured.trim() == value,
-                "runtime event version already set to {}",
+                "runtime event version is already set to {} for this boot and cannot be \
+                 changed to {value}; the setting is fixed when system setup runs, so restart \
+                 the CVM to apply a new app-compose `event_log_version`",
                 configured.trim()
             );
             Ok(())
@@ -105,7 +116,12 @@ mod runtime_event_version_tests {
         set_runtime_event_version_file(&path, EventLogVersion::V1).unwrap();
         set_runtime_event_version_file(&path, EventLogVersion::V1).unwrap();
         let err = set_runtime_event_version_file(&path, EventLogVersion::V2).unwrap_err();
-        assert!(err.to_string().contains("already set to 1"));
+        let message = err.to_string();
+        assert!(message.contains("already set to 1"), "{message}");
+        assert!(
+            message.contains("restart the CVM"),
+            "the conflict error must tell the operator how to apply a new version: {message}"
+        );
         let _ = fs_err::remove_file(path);
     }
 

sdk/go/dstack/client.go

@@ -130,8 +130,13 @@ type EventLog struct {
 	Digest       string `json:"digest"`
 	Event        string `json:"event"`
 	EventPayload string `json:"event_payload"`
-	Version      int    `json:"version,omitempty"`
-	Preimage     string `json:"preimage,omitempty"`
+	// Runtime event log version. The field is omitted from the wire format for
+	// version 1, so a zero value means V1 rather than "unset"; treat 0 and 1
+	// alike. Only dstack runtime events carry a version.
+	Version int `json:"version,omitempty"`
+	// Hex-encoded digest pre-image, present on V2 runtime events. When set,
+	// sha384(hex_decode(Preimage)) equals Digest.
+	Preimage string `json:"preimage,omitempty"`
 }
 
 // Represents the TCB information