feat: record external generation runs

server-rs/crates/api-server/src/vector_engine_audio_generation/generation.rs

@@ -1,9 +1,12 @@
+use serde_json::json;
 use shared_contracts::creation_audio;
 
-use crate::{http_error::AppError, state::AppState};
+use crate::{
+    http_error::AppError, state::AppState, tracking::record_external_generation_run_after_success,
+};
 
 use super::{
-    clock::current_utc_iso_text,
+    clock::{current_utc_iso_text, current_utc_micros},
     errors::{map_platform_audio_error, vector_engine_bad_gateway},
     publish::wait_for_generated_audio_asset,
     tasks::{create_background_music_task_response, create_sound_effect_task_response},
@@ -18,45 +21,69 @@ pub(crate) async fn generate_sound_effect_asset_for_creation(
     seed: Option<u64>,
     target: GeneratedCreationAudioTarget,
 ) -> Result<creation_audio::CreationAudioAsset, AppError> {
+    let started_at_micros = current_utc_micros();
     let normalized_prompt = platform_audio::normalize_limited_text(
         &prompt,
         "prompt",
         platform_audio::VIDU_PROMPT_MAX_CHARS,
     )
     .map_err(map_platform_audio_error)?;
-    let task =
-        create_sound_effect_task_response(state, normalized_prompt.clone(), duration, seed).await?;
-    let target = AudioAssetBindingTarget {
-        storage_scope: target.entity_kind.clone(),
-        entity_kind: target.entity_kind,
-        entity_id: target.entity_id,
-        slot: target.slot,
-        asset_kind: target.asset_kind,
-        profile_id: target.profile_id,
-        storage_prefix: target.storage_prefix,
-    };
-    let generated = wait_for_generated_audio_asset(
-        state,
-        owner_user_id,
-        task.task_id.clone(),
-        AudioAssetSlot::SoundEffect,
-        target,
-    )
-    .await?;
-    let audio_src = generated
-        .audio_src
-        .ok_or_else(|| vector_engine_bad_gateway("音效生成完成但缺少播放地址"))?;
+    let request_payload = json!({
+        "kind": "sound_effect",
+        "promptChars": normalized_prompt.chars().count(),
+        "duration": duration,
+        "seed": seed,
+        "targetEntityKind": target.entity_kind,
+        "targetEntityId": target.entity_id,
+        "targetSlot": target.slot,
+        "targetAssetKind": target.asset_kind,
+    });
+    let outcome = async {
+        let task =
+            create_sound_effect_task_response(state, normalized_prompt.clone(), duration, seed)
+                .await?;
+        let target = AudioAssetBindingTarget {
+            storage_scope: target.entity_kind.clone(),
+            entity_kind: target.entity_kind,
+            entity_id: target.entity_id,
+            slot: target.slot,
+            asset_kind: target.asset_kind,
+            profile_id: target.profile_id,
+            storage_prefix: target.storage_prefix,
+        };
+        let generated = wait_for_generated_audio_asset(
+            state,
+            owner_user_id,
+            task.task_id.clone(),
+            AudioAssetSlot::SoundEffect,
+            target,
+        )
+        .await?;
+        let audio_src = generated
+            .audio_src
+            .ok_or_else(|| vector_engine_bad_gateway("音效生成完成但缺少播放地址"))?;
 
-    Ok(creation_audio::CreationAudioAsset {
-        task_id: generated.task_id,
-        provider: generated.provider,
-        asset_object_id: generated.asset_object_id,
-        asset_kind: generated.asset_kind,
-        audio_src,
-        prompt: Some(normalized_prompt),
-        title: None,
-        updated_at: Some(current_utc_iso_text()),
-    })
+        Ok::<_, AppError>(creation_audio::CreationAudioAsset {
+            task_id: generated.task_id,
+            provider: generated.provider,
+            asset_object_id: generated.asset_object_id,
+            asset_kind: generated.asset_kind,
+            audio_src,
+            prompt: Some(normalized_prompt),
+            title: None,
+            updated_at: Some(current_utc_iso_text()),
+        })
+    }
+    .await;
+    record_creation_audio_generation_run(
+        state,
+        "sound_effect",
+        request_payload,
+        started_at_micros,
+        &outcome,
+    )
+    .await;
+    outcome
 }
 
 pub(crate) async fn generate_background_music_asset_for_creation(
@@ -68,6 +95,7 @@ pub(crate) async fn generate_background_music_asset_for_creation(
     model: Option<String>,
     target: GeneratedCreationAudioTarget,
 ) -> Result<creation_audio::CreationAudioAsset, AppError> {
+    let started_at_micros = current_utc_micros();
     let normalized_prompt = platform_audio::normalize_limited_text_allow_empty(
         &prompt,
         "prompt",
@@ -80,43 +108,111 @@ pub(crate) async fn generate_background_music_asset_for_creation(
         platform_audio::SUNO_TITLE_MAX_CHARS,
     )
     .map_err(map_platform_audio_error)?;
-    let task = create_background_music_task_response(
-        state,
-        normalized_prompt.clone(),
-        normalized_title.clone(),
-        tags,
-        model,
-    )
-    .await?;
-    let target = AudioAssetBindingTarget {
-        storage_scope: target.entity_kind.clone(),
-        entity_kind: target.entity_kind,
-        entity_id: target.entity_id,
-        slot: target.slot,
-        asset_kind: target.asset_kind,
-        profile_id: target.profile_id,
-        storage_prefix: target.storage_prefix,
-    };
-    let generated = wait_for_generated_audio_asset(
-        state,
-        owner_user_id,
-        task.task_id.clone(),
-        AudioAssetSlot::BackgroundMusic,
-        target,
-    )
-    .await?;
-    let audio_src = generated
-        .audio_src
-        .ok_or_else(|| vector_engine_bad_gateway("背景音乐生成完成但缺少播放地址"))?;
+    let request_payload = json!({
+        "kind": "background_music",
+        "promptChars": normalized_prompt.chars().count(),
+        "titleChars": normalized_title.chars().count(),
+        "hasTags": tags.as_ref().is_some_and(|value| !value.trim().is_empty()),
+        "model": model,
+        "targetEntityKind": target.entity_kind,
+        "targetEntityId": target.entity_id,
+        "targetSlot": target.slot,
+        "targetAssetKind": target.asset_kind,
+    });
+    let outcome = async {
+        let task = create_background_music_task_response(
+            state,
+            normalized_prompt.clone(),
+            normalized_title.clone(),
+            tags,
+            model,
+        )
+        .await?;
+        let target = AudioAssetBindingTarget {
+            storage_scope: target.entity_kind.clone(),
+            entity_kind: target.entity_kind,
+            entity_id: target.entity_id,
+            slot: target.slot,
+            asset_kind: target.asset_kind,
+            profile_id: target.profile_id,
+            storage_prefix: target.storage_prefix,
+        };
+        let generated = wait_for_generated_audio_asset(
+            state,
+            owner_user_id,
+            task.task_id.clone(),
+            AudioAssetSlot::BackgroundMusic,
+            target,
+        )
+        .await?;
+        let audio_src = generated
+            .audio_src
+            .ok_or_else(|| vector_engine_bad_gateway("背景音乐生成完成但缺少播放地址"))?;
 
-    Ok(creation_audio::CreationAudioAsset {
-        task_id: generated.task_id,
-        provider: generated.provider,
-        asset_object_id: generated.asset_object_id,
-        asset_kind: generated.asset_kind,
-        audio_src,
-        prompt: Some(normalized_prompt),
-        title: Some(normalized_title),
-        updated_at: Some(current_utc_iso_text()),
-    })
+        Ok::<_, AppError>(creation_audio::CreationAudioAsset {
+            task_id: generated.task_id,
+            provider: generated.provider,
+            asset_object_id: generated.asset_object_id,
+            asset_kind: generated.asset_kind,
+            audio_src,
+            prompt: Some(normalized_prompt),
+            title: Some(normalized_title),
+            updated_at: Some(current_utc_iso_text()),
+        })
+    }
+    .await;
+    record_creation_audio_generation_run(
+        state,
+        "background_music",
+        request_payload,
+        started_at_micros,
+        &outcome,
+    )
+    .await;
+    outcome
+}
+
+async fn record_creation_audio_generation_run(
+    state: &AppState,
+    operation: &'static str,
+    request_payload: serde_json::Value,
+    started_at_micros: i64,
+    outcome: &Result<creation_audio::CreationAudioAsset, AppError>,
+) {
+    match outcome {
+        Ok(asset) => {
+            record_external_generation_run_after_success(
+                state,
+                asset.provider.as_str(),
+                operation,
+                "创作音频生成",
+                request_payload,
+                started_at_micros,
+                true,
+                None,
+                Some(asset.task_id.clone()),
+                Some(json!({
+                    "assetObjectId": asset.asset_object_id,
+                    "assetKind": asset.asset_kind,
+                    "hasAudioSrc": !asset.audio_src.trim().is_empty(),
+                })),
+            )
+            .await;
+        }
+        Err(error) => {
+            record_external_generation_run_after_success(
+                state,
+                "vector-engine-audio",
+                operation,
+                "创作音频生成",
+                request_payload,
+                started_at_micros,
+                false,
+                Some(error.to_string()),
+                None,
+                None,
+            )
+            .await;
+        }
+    }
 }