Make TranscodePreviewVX tolerant of missing per-language shape-tags

When previewing MU2/CLN files, the workflow generates an audio preview track
for every language defined in LanguagesByMU2/LanguageBySoftron and tries to
register each as a Vidispine shape using the language's MBPreviewTag. For
languages whose tag is not configured in Vidispine (e.g. mul_yue_low), the
import would fail and tank the entire preview workflow.

- Iterate the audio preview map deterministically with GetMapKeysSafely.
- Skip languages with an empty MBPreviewTag.
- Treat per-language import failures as non-fatal: log + telegram warning,
  then continue. Don't leak the loop variable through return err.
- Parse Vidispine's structured error envelope in AddShapeToItem and surface
  shape-tag-not-found via ErrShapeTagNotFound. ImportFileAsShapeActivity
  wraps that as a non-retryable Temporal error so missing tags fail fast
  instead of burning through the default retry policy.
- Add unit tests for parseVSError covering the shape-tag, generic, and
  non-JSON cases.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: KillerX

activities/vidispine/files.go

@@ -2,10 +2,12 @@ package vsactivity
 
 import (
 	"context"
+	"errors"
 
 	"github.com/bcc-code/bcc-media-flows/paths"
 	"github.com/bcc-code/bcc-media-flows/services/vidispine/vsapi"
 	"go.temporal.io/sdk/activity"
+	"go.temporal.io/sdk/temporal"
 )
 
 type ImportFileAsShapeParams struct {
@@ -53,6 +55,9 @@ func (a Activities) ImportFileAsShapeActivity(ctx context.Context, params Import
 	}
 
 	res, err := vsClient.AddShapeToItem(params.ShapeTag, params.AssetID, fileID)
+	if err != nil && errors.Is(err, vsapi.ErrShapeTagNotFound) {
+		err = temporal.NewNonRetryableApplicationError(err.Error(), "VS_SHAPE_TAG_NOT_FOUND", err)
+	}
 	return &ImportFileResult{
 		JobID:  res,
 		FileID: fileID,

services/vidispine/vsapi/shapes.go

@@ -1,6 +1,8 @@
 package vsapi
 
 import (
+	"encoding/json"
+	"errors"
 	"fmt"
 	"net/url"
 
@@ -11,6 +13,31 @@ import (
 	"github.com/samber/lo"
 )
 
+// ErrShapeTagNotFound is returned by AddShapeToItem when Vidispine reports
+// that the requested shape-tag is not configured. Wrap-aware: callers can
+// detect this with errors.Is and treat it as a configuration error rather
+// than a transient failure.
+var ErrShapeTagNotFound = errors.New("shape-tag not found in Vidispine")
+
+// vsErrorBody mirrors the structured error envelope Vidispine returns on
+// non-2xx responses. Only the fields we need are populated; the rest are
+// kept as raw messages so unknown failure modes still surface in the error
+// string.
+type vsErrorBody struct {
+	NotFound *struct {
+		Type string `json:"type"`
+		ID   string `json:"id"`
+	} `json:"notFound"`
+	InternalServer  json.RawMessage `json:"internalServer"`
+	Forbidden       json.RawMessage `json:"forbidden"`
+	NotYetImpl      json.RawMessage `json:"notYetImplemented"`
+	Conflict        json.RawMessage `json:"conflict"`
+	InvalidInput    json.RawMessage `json:"invalidInput"`
+	LicenseFault    json.RawMessage `json:"licenseFault"`
+	FileExists      json.RawMessage `json:"fileAlreadyExists"`
+	NotAuthorized   json.RawMessage `json:"notAuthorized"`
+}
+
 func (c *Client) GetShapes(vsID string) (*ShapeResult, error) {
 	url := c.baseURL + "/item/" + vsID + "?content=shape&terse=true"
 
@@ -45,14 +72,34 @@ func (c *Client) AddShapeToItem(tag, itemID, fileID string) (string, error) {
 		return "", err
 	}
 
+	if result.IsError() {
+		return "", parseVSError(result.Body(), result.StatusCode(), tag, itemID)
+	}
+
 	jobID := result.Result().(*JobDocument).JobID
 	if jobID == "" {
-		return "", fmt.Errorf("No job id Returned. Body: %s", string(result.Body()))
+		return "", parseVSError(result.Body(), result.StatusCode(), tag, itemID)
 	}
 
 	spew.Dump(result.Result())
 
-	return result.Result().(*JobDocument).JobID, nil
+	return jobID, nil
+}
+
+// parseVSError turns a Vidispine error envelope into a descriptive error.
+// Shape-tag-not-found is returned wrapped around ErrShapeTagNotFound so
+// callers can detect it with errors.Is and avoid wasteful retries.
+func parseVSError(body []byte, statusCode int, tag, itemID string) error {
+	var e vsErrorBody
+	if jsonErr := json.Unmarshal(body, &e); jsonErr != nil {
+		return fmt.Errorf("vidispine request failed (status %d): %s", statusCode, string(body))
+	}
+
+	if e.NotFound != nil && e.NotFound.Type == "shape-tag" {
+		return fmt.Errorf("shape-tag %q not configured in Vidispine (item %s): %w", e.NotFound.ID, itemID, ErrShapeTagNotFound)
+	}
+
+	return fmt.Errorf("vidispine request failed (status %d) for tag %q on item %s: %s", statusCode, tag, itemID, string(body))
 }
 
 func (c *Client) DeleteShape(assetID, shapeID string) error {

services/vidispine/vsapi/shapes_test.go

@@ -1,11 +1,47 @@
 package vsapi
 
 import (
+	"errors"
+	"net/http"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
+func Test_parseVSError_ShapeTagNotFound(t *testing.T) {
+	body := []byte(`{"notFound":{"type":"shape-tag","id":"mul_yue_low","context":null},"internalServer":null,"forbidden":null,"notYetImplemented":null,"conflict":null,"invalidInput":null,"licenseFault":null,"fileAlreadyExists":null,"notAuthorized":null}`)
+
+	err := parseVSError(body, http.StatusNotFound, "mul_yue_low", "VX-123")
+
+	assert.Error(t, err)
+	assert.True(t, errors.Is(err, ErrShapeTagNotFound), "expected error to wrap ErrShapeTagNotFound")
+	assert.Contains(t, err.Error(), "mul_yue_low")
+	assert.Contains(t, err.Error(), "VX-123")
+}
+
+func Test_parseVSError_OtherEnvelope(t *testing.T) {
+	body := []byte(`{"notFound":null,"forbidden":{},"internalServer":null}`)
+
+	err := parseVSError(body, http.StatusForbidden, "lowres_watermarked", "VX-456")
+
+	assert.Error(t, err)
+	assert.False(t, errors.Is(err, ErrShapeTagNotFound), "non-shape-tag errors must not wrap ErrShapeTagNotFound")
+	assert.Contains(t, err.Error(), "403")
+	assert.Contains(t, err.Error(), "lowres_watermarked")
+	assert.Contains(t, err.Error(), "VX-456")
+}
+
+func Test_parseVSError_NonJSONBody(t *testing.T) {
+	body := []byte(`<html>internal server error</html>`)
+
+	err := parseVSError(body, http.StatusInternalServerError, "tag", "VX-789")
+
+	assert.Error(t, err)
+	assert.False(t, errors.Is(err, ErrShapeTagNotFound))
+	assert.Contains(t, err.Error(), "500")
+	assert.Contains(t, err.Error(), "<html>internal server error</html>")
+}
+
 func Test_GetPath(t *testing.T) {
 	sr := ShapeResult{
 		Shape: []Shape{

workflows/misc/transcode_preview-vx.go

@@ -3,14 +3,14 @@ package miscworkflows
 import (
 	"fmt"
 	bccmflows "github.com/bcc-code/bcc-media-flows"
-	"github.com/bcc-code/mediabank-bridge/log"
 	"github.com/samber/lo"
 	"path/filepath"
 	"strings"
 	"time"
 
 	"github.com/bcc-code/bcc-media-flows/activities"
 	vsactivity "github.com/bcc-code/bcc-media-flows/activities/vidispine"
+	"github.com/bcc-code/bcc-media-flows/services/telegram"
 	wfutils "github.com/bcc-code/bcc-media-flows/utils/workflows"
 
 	"go.temporal.io/sdk/workflow"
@@ -87,18 +87,33 @@ func TranscodePreviewVX(
 		return err
 	}
 
-	for l, p := range previewResponse.AudioPreviewFiles {
+	audioLangs, err := wfutils.GetMapKeysSafely(ctx, previewResponse.AudioPreviewFiles)
+	if err != nil {
+		return err
+	}
+
+	for _, l := range audioLangs {
+		p := previewResponse.AudioPreviewFiles[l]
 		tag := bccmflows.LanguagesByISO[l].MBPreviewTag
-		err = wfutils.Execute(ctx, activities.Vidispine.ImportFileAsShapeActivity,
+		if tag == "" {
+			logger.Info("Skipping audio preview with empty MBPreviewTag", "language", l)
+			continue
+		}
+
+		iterErr := wfutils.Execute(ctx, activities.Vidispine.ImportFileAsShapeActivity,
 			vsactivity.ImportFileAsShapeParams{
 				AssetID:  params.VXID,
 				FilePath: p,
 				ShapeTag: tag,
 			}).Wait(ctx)
-		if err != nil {
-			log.L.Log().Err(err).Msg("Error importing audio preview")
+		if iterErr != nil {
+			logger.Error("Failed to import audio preview shape",
+				"language", l, "tag", tag, "vxid", params.VXID, "error", iterErr.Error())
+			wfutils.SendTelegramText(ctx, telegram.ChatOther,
+				fmt.Sprintf("🟧 Failed to import audio preview for `%s` (tag `%s`) on `%s`: ```%s```",
+					l, tag, params.VXID, iterErr.Error()))
 		}
 	}
 
-	return err
+	return nil
 }