feat(dgw): list Gateway-generated artifacts in the recording manifest

devolutions-gateway/src/api/jrec.rs

@@ -28,6 +28,7 @@ use zip::write::SimpleFileOptions;
 
 use crate::DgwState;
 use crate::api::heartbeat::recording_storage_health;
+use crate::artifacts::JrecArtifacts;
 use crate::extract::{JrecToken, RecordingDeleteScope, RecordingsReadScope};
 use crate::http::{HttpError, HttpErrorBuilder};
 use crate::recording::{PushOutcome, RecordingMessageSender};
@@ -36,7 +37,7 @@ use crate::token::{JrecTokenClaims, RecordingFileType, RecordingOperation};
 /// Read chunk size when streaming a finished session ZIP from the temp file.
 const ZIP_CHUNK_SIZE: usize = 64 * 1024;
 
-/// Maximum files in a session ZIP (`recording.json` + clips).
+/// Maximum files in a session ZIP (`recording.json` + clips and artifacts).
 ///
 /// Reconnect windows only mint a small number of clips per session in practice;
 /// this bound blocks pathological manifests without rejecting normal multi-clip packages.
@@ -633,6 +634,8 @@ where
 #[serde(rename_all = "camelCase")]
 struct RecordingZipManifest {
     files: Vec<RecordingZipManifestFile>,
+    #[serde(default)]
+    artifacts: JrecArtifacts,
 }
 
 #[derive(Debug, Deserialize)]
@@ -672,7 +675,7 @@ impl RecordingZipPlan {
     }
 }
 
-/// Snapshots `recording.json` and the clip files it references at call time.
+/// Snapshots `recording.json` and the clip and artifact files it references at call time.
 async fn snapshot_recording_zip_plan(recording_dir: &Utf8Path) -> Result<RecordingZipPlan, HttpError> {
     let manifest_path = recording_dir.join("recording.json");
     let manifest_bytes = tokio::fs::read(&manifest_path).await.map_err(|error| {
@@ -695,22 +698,27 @@ async fn snapshot_recording_zip_plan(recording_dir: &Utf8Path) -> Result<Recordi
         HttpError::not_found().msg("requested recording does not exist")
     })?;
 
-    let mut clip_names = Vec::with_capacity(manifest.files.len());
-    for file in manifest.files {
-        if !is_safe_recording_file_name(&file.file_name) {
+    let file_names = manifest
+        .files
+        .into_iter()
+        .map(|file| file.file_name)
+        .chain(manifest.artifacts.into_file_names());
+    let mut clip_names = Vec::with_capacity(file_names.size_hint().0);
+    for file_name in file_names {
+        if !is_safe_recording_file_name(&file_name) {
             warn!(
-                file_name = %file.file_name,
+                %file_name,
                 "Skipping unsafe recording file name from manifest"
             );
             continue;
         }
 
-        let path = recording_dir.join(&file.file_name);
+        let path = recording_dir.join(&file_name);
         if path.is_file() {
-            clip_names.push(file.file_name);
+            clip_names.push(file_name);
         } else {
             warn!(
-                file_name = %file.file_name,
+                %file_name,
                 path = %path,
                 "Skipping missing recording file listed in manifest"
             );
@@ -1091,6 +1099,44 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn snapshots_manifest_artifacts_for_zip() {
+        let dir = tempfile::tempdir().expect("temp dir");
+        let dir_path = Utf8PathBuf::from_path_buf(dir.path().to_path_buf()).expect("utf8 path");
+
+        let manifest = serde_json::json!({
+            "sessionId": "33333333-3333-3333-3333-333333333333",
+            "startTime": 1,
+            "duration": 5,
+            "files": [
+                { "fileName": "recording-0.webm", "startTime": 1, "duration": 5 }
+            ],
+            "artifacts": {
+                "ai-analysis": [
+                    { "fileName": "ai-analysis-0.slog" },
+                    { "fileName": "ai-analysis-1.slog" }
+                ]
+            }
+        });
+
+        tokio::fs::write(dir_path.join("recording.json"), manifest.to_string())
+            .await
+            .expect("write manifest");
+        for file_name in ["recording-0.webm", "ai-analysis-0.slog", "ai-analysis-1.slog"] {
+            tokio::fs::write(dir_path.join(file_name), b"content")
+                .await
+                .expect("write artifact");
+        }
+
+        let plan = snapshot_recording_zip_plan(&dir_path)
+            .await
+            .unwrap_or_else(|error| panic!("snapshot plan: {error}"));
+        assert_eq!(
+            plan.clip_names,
+            ["recording-0.webm", "ai-analysis-0.slog", "ai-analysis-1.slog"]
+        );
+    }
+
     #[tokio::test]
     async fn zip_keeps_snapshotted_manifest_when_disk_manifest_changes() {
         let dir = tempfile::tempdir().expect("temp dir");

devolutions-gateway/src/artifacts.rs

@@ -0,0 +1,79 @@
+use serde::{Deserialize, Serialize};
+
+use crate::token::RecordingFileType;
+
+/// Non-recording artifacts, one list per [`ArtifactKind`]. Each list is append-only, like `files`: names
+/// are derived from positions.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub(crate) struct JrecArtifacts {
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    ai_analysis: Vec<JrecArtifact>,
+}
+
+impl JrecArtifacts {
+    pub(crate) fn is_empty(&self) -> bool {
+        let Self { ai_analysis } = self;
+        ai_analysis.is_empty()
+    }
+
+    pub(crate) fn into_file_names(self) -> impl IntoIterator<Item = String> {
+        let Self { ai_analysis } = self;
+        ai_analysis.into_iter().map(|artifact| artifact.file_name)
+    }
+
+    pub(crate) fn of_kind_mut(&mut self, kind: ArtifactKind) -> &mut Vec<JrecArtifact> {
+        match kind {
+            ArtifactKind::AiAnalysis => &mut self.ai_analysis,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct JrecArtifact {
+    pub(crate) file_name: String,
+}
+
+/// Kind of a non-recording artifact, used as its key in the manifest `artifacts` object.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ArtifactKind {
+    AiAnalysis,
+}
+
+impl ArtifactKind {
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            ArtifactKind::AiAnalysis => "ai-analysis",
+        }
+    }
+
+    pub(crate) const fn file_type(self) -> RecordingFileType {
+        match self {
+            ArtifactKind::AiAnalysis => RecordingFileType::SessionRecordingLog,
+        }
+    }
+
+    /// Name of the artifact at `index` in its kind's list, such as `ai-analysis-0.slog`.
+    pub(crate) fn file_name(self, index: usize) -> String {
+        format!("{}-{index}.{}", self.as_str(), self.file_type().extension())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn manifest_key_is_the_kind_name() {
+        let kind = ArtifactKind::AiAnalysis;
+        let mut artifacts = JrecArtifacts::default();
+        artifacts.of_kind_mut(kind).push(JrecArtifact {
+            file_name: "file".to_owned(),
+        });
+
+        let json = serde_json::to_value(&artifacts).expect("serialize artifacts");
+        let keys: Vec<_> = json.as_object().expect("object").keys().collect();
+        assert_eq!(keys, [kind.as_str()]);
+    }
+}

devolutions-gateway/src/lib.rs

@@ -13,6 +13,7 @@ extern crate tracing;
 pub mod openapi;
 
 pub mod api;
+pub mod artifacts;
 pub mod cli;
 pub mod config;
 pub mod credential;

devolutions-gateway/src/recording.intent.md

@@ -0,0 +1,10 @@
+# Recording
+Gateway recording is a continuous stream of bytes pushed from the client who pocesses the valid recording token.
+The url is `/jet/jrec/push/{sessionId}?fileType={fileType}`.
+We expect the `fileType` to be one of the following file types: `webm`, `cast`, `trp` and `slog`, which must be specified.
+When connection is established with request of recordings for the session, if recording is not enabled within a short period of time, the connection will be closed with indication of violation of the recording policy.
+
+
+# Artifacts
+Artifacts are files that are not recordings, currently only have `ai-analysis` with combination to `slog` file type.
+Currently, we do not have an api endpoint to push artifacts, but we will have one in the future.