Skip to content

Commit 00f08e8

Browse files
vanceingallsclaude
andauthored
fix(producer): attach src URL to ffprobe failures for compile-phase attribution (STUDIO-5433) (#3033)
* fix(producer): attach src URL to ffprobe failures for compile-phase attribution (STUDIO-5433) Wrap the video-branch `extractMediaMetadata` and `probeMediaProfile` calls in `resolveMediaDuration` (`packages/producer/src/services/htmlCompiler.ts`) with a `withSrcContext` helper that re-throws with the remote `src` appended as `[src=<url>]`. The URL is passed through `redactTelemetryString` first so pre-signed URL signatures never reach telemetry. STUDIO-5433 — enterprise customer `[email protected]` was blocked from generating AI Studio videos, surfacing in Datadog as `[FFmpeg] ffprobe exit with code 1: [mov,mp4,m4a,3gp,3g2,mj2 @ 0x...] moov atom not found\n[input]: Invalid data found when processing input`. `runFfprobe` at `engine/utils/ffprobe.ts:74-79` intentionally redacts the local `filePath` from the error (see `redactFfprobeInput` — same file, lines 13-35), so the failure carries no attribution and identifying the offending source requires dumping the Temporal activity history for the workflow. That dump is expensive-per-occurrence and blocks debugging on operator availability. The demuxer signature (`mov,mp4,m4a,3gp,3g2,mj2`) tells us the file is MOV/MP4-family, and the workflow_id tells us which HyperFrames composition element failed — but the *actual URL* that ffprobe was handed is lost. This change surfaces the URL so the next occurrence is diagnosable directly from the render error in Datadog, without a Temporal history dump. Preserves fail-fast semantics: the video branch still throws (aborts the compile), unlike the audio branch's deliberate graceful-degrade to `duration=0`. Only the error *message* is enriched; the control flow is unchanged. 1. `packages/producer/src/services/htmlCompiler.ts` - New `withSrcContext(error)` helper inside `resolveMediaDuration` that wraps `error.message` with `[src=<redactTelemetryString(src)>]` and preserves the original stack. - Video-branch `probeMediaProfile` catch re-throws via `withSrcContext` (was: bare `throw error`). - Video-branch `extractMediaMetadata` newly wrapped in try/catch that re-throws via `withSrcContext` (was: uncaught, so the caller saw the bare `[input]`-redacted ffprobe message). - Adds `redactTelemetryString` import from `@hyperframes/core` (already re-exported at `packages/core/src/index.ts:255`). 2. `packages/producer/src/services/htmlCompiler.test.ts` - New `describe("STUDIO-5433 — ffprobe failure includes src URL for attribution")` block with a `compileForRender` integration test: writes a 0-byte `assets/clip.mp4`, references it from an `<video src>` tag, asserts the thrown error message contains `[src=assets/clip.mp4]` AND still carries the original ffprobe diagnostic so downstream failure classifiers continue to match. - [x] Repro locally: 0-byte mp4 → `compileForRender` → error message contains `[src=assets/clip.mp4]` (test above). - [x] Preserves fail-fast semantics — video branch still throws (assertion on thrown error). - [ ] Focused CI must pass; hosted CI to follow. - [ ] Follow-up (separate PR pending URL recovery): identify the writer that produces the actual failing derivative and add `_probe_section_integrity` fail-closed at the write site (the durable fix — this PR is diagnosability defense-in-depth). <!-- pr-check:enterprise-ff:start --> - [x] This change is not behind a feature flag (small diagnostic improvement on an existing error path; preserves failure semantics unchanged). - [ ] This change is behind a feature flag <!-- pr-check:enterprise-ff:end --> <!-- pr-check:ui-impact --> - [x] <!-- pr-opt:no-ui-impact --> No UI impact — enriches a producer-worker error message read only in Datadog. Co-Authored-By: Claude Opus 4.7 <[email protected]> * fix(producer): pass typed routing errors through the src-context wrapper `withSrcContext` rebuilt every error as a bare `new Error(...)`, which dropped `NotMediaPayloadError`'s `.code = "NOT_MEDIA_PAYLOAD"`, `.owner = "user"`, `.retryable = false` and `.elementFingerprints`. `SAFE_RENDER_ERROR_CODES` and the distributed retry set both key on those, so a `<video>` src pointing at an HTML payload — the STUDIO-5433 root case — flipped from NOT_MEDIA_PAYLOAD/user/no-retry to generic/system/retryable: it paged ops and re-ran the render on a user-input bug. The existing sniff regression ("aborts with NotMediaPayloadError before ffprobe…") is the pin; it fails on the removal of this one line. The PR's own new test also asserted `[src=assets/clip.mp4]`, but a bare relative path matches `telemetryRedaction`'s BARE_RELATIVE_PATH shape and redacts to `[path]`. Assert what the redactor actually produces for a local src, and pin the case the ticket is about — a remote URL, where host and path survive and only the pre-signed query is dropped — directly on the redactor. --------- Co-authored-by: Claude Opus 4.7 <[email protected]>
1 parent 13c8672 commit 00f08e8

2 files changed

Lines changed: 100 additions & 2 deletions

File tree

‎packages/producer/src/services/htmlCompiler.test.ts‎

Lines changed: 68 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@ import { join } from "node:path";
66
import { runInThisContext } from "node:vm";
77
import { parseHTML } from "linkedom";
88
import { interpolateVolumeGain } from "@hyperframes/core/media-volume-envelope";
9+
import { redactTelemetryString } from "@hyperframes/core";
910
import { defaultLogger } from "../logger.js";
1011
import { NotMediaPayloadError } from "@hyperframes/engine";
1112
import {
@@ -2763,3 +2764,70 @@ describe("duplicate media ids across nested compositions", () => {
27632764
expect(compiled.audios[1]).toMatchObject({ start: 3, end: 6, mediaStart: 50 });
27642765
});
27652766
});
2767+
2768+
describe("STUDIO-5433 — ffprobe failure includes src URL for attribution", () => {
2769+
function writeCorruptVideoProject(videoSrc: string, assetBytes: Buffer): string {
2770+
const projectDir = mkdtempSync(join(tmpdir(), "hf-studio-5433-"));
2771+
mkdirSync(join(projectDir, "assets"), { recursive: true });
2772+
writeFileSync(join(projectDir, "assets", "clip.mp4"), assetBytes);
2773+
writeFileSync(
2774+
join(projectDir, "index.html"),
2775+
`<!DOCTYPE html>
2776+
<html>
2777+
<body>
2778+
<div id="root" data-composition-id="root" data-start="0" data-duration="4" data-width="640" data-height="360">
2779+
<video
2780+
id="clip"
2781+
src="${videoSrc}"
2782+
data-start="0"
2783+
data-duration="4"
2784+
data-width="640"
2785+
data-height="360"
2786+
></video>
2787+
</div>
2788+
<script>
2789+
window.__timelines = window.__timelines || {};
2790+
window.__timelines["root"] = { duration: () => 4 };
2791+
</script>
2792+
</body>
2793+
</html>`,
2794+
);
2795+
return projectDir;
2796+
}
2797+
2798+
it("wraps the ffprobe error with [src=<relative-path>] when the local video is corrupt", async () => {
2799+
// 0-byte mp4 — ffprobe reports "Invalid data found when processing input",
2800+
// the same class as the STUDIO-5433 moov failure. Fail-fast semantics remain
2801+
// (video branch throws, unlike audio's graceful-degrade to duration=0).
2802+
const projectDir = writeCorruptVideoProject("assets/clip.mp4", Buffer.alloc(0));
2803+
2804+
let thrown: unknown;
2805+
try {
2806+
await compileForRender(projectDir, join(projectDir, "index.html"), projectDir);
2807+
} catch (error) {
2808+
thrown = error;
2809+
}
2810+
2811+
expect(thrown).toBeInstanceOf(Error);
2812+
const message = (thrown as Error).message;
2813+
// A bare relative path IS the redactor's `BARE_RELATIVE_PATH` shape (one
2814+
// separator + a media extension), so it lands as `[path]`. The attribution
2815+
// that matters is the remote-URL case below; a local relative src carries
2816+
// no host to attribute and the redactor is right to drop it.
2817+
expect(message).toContain("[src=[path]]");
2818+
// Original ffprobe diagnostic must still be present so failure classifiers
2819+
// downstream (e.g. hyperframes_render_metrics.py) continue to match.
2820+
expect(message).toMatch(/ffprobe|Invalid data|No video stream/i);
2821+
});
2822+
2823+
// The STUDIO-5433 case is a remote src, and that is the shape whose
2824+
// attribution has to survive redaction: host + path kept, query dropped so a
2825+
// pre-signed signature never reaches telemetry. Pinned on the redactor
2826+
// directly — driving a remote src through `compileForRender` would need a
2827+
// download stub, and the wrapper's only transform IS this call.
2828+
it("keeps host and path but drops the query when redacting a remote src", () => {
2829+
expect(redactTelemetryString("https://cdn.example.com/renders/clip.mp4?sig=abc123&exp=1")).toBe(
2830+
"https://cdn.example.com/renders/clip.mp4?\u2026",
2831+
);
2832+
});
2833+
});

‎packages/producer/src/services/htmlCompiler.ts‎

Lines changed: 32 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@ import {
2323
isNonRelativeUrl,
2424
parseStrictFiniteTimingNumber,
2525
readMediaStart,
26+
redactTelemetryString,
2627
resolveNaturalMediaTimelineDurationFromValues,
2728
type ResolvedDuration,
2829
type UnresolvedElement,
@@ -444,6 +445,31 @@ async function resolveMediaDuration(
444445
return { duration: null, resolvedPath: filePath };
445446
}
446447

448+
// STUDIO-5433: attach the remote `src` to any ffprobe failure surfaced from
449+
// this branch. `extractMediaMetadata` → `runFfprobe` intentionally redacts
450+
// its local `filePath` out of the error message (see
451+
// engine/utils/ffprobe.ts::redactFfprobeInput), so a bare `moov atom not
452+
// found` in Datadog carries no attribution and requires a Temporal history
453+
// dump to identify the offending source. Re-throwing with the `src`
454+
// (query-string redacted via `redactTelemetryString` so pre-signed URL
455+
// signatures never reach telemetry) makes the next occurrence diagnosable
456+
// directly from the render error. Fail-fast semantics for the video branch
457+
// are preserved — only the message is enriched.
458+
const withSrcContext = (error: unknown): Error => {
459+
// A NotMediaPayloadError already carries its own attribution AND the
460+
// routing metadata downstream keys on — `.code = "NOT_MEDIA_PAYLOAD"`,
461+
// `.owner = "user"`, `.retryable = false`, `.elementFingerprints`. Wrapping
462+
// it in a bare Error drops all four, flipping a user-input bug to
463+
// generic/system/retryable: it pages ops and re-runs the render. Pass it
464+
// through untouched.
465+
if (error instanceof NotMediaPayloadError) return error;
466+
const originalMessage = error instanceof Error ? error.message : String(error);
467+
const safeSrc = redactTelemetryString(src);
468+
const wrapped = new Error(`${originalMessage} [src=${safeSrc}]`);
469+
if (error instanceof Error && error.stack) wrapped.stack = error.stack;
470+
return wrapped;
471+
};
472+
447473
return withMediaProbeSlot(async () => {
448474
let profile: MediaProbeProfile;
449475
try {
@@ -471,13 +497,17 @@ async function resolveMediaDuration(
471497
}
472498
return { duration: null, resolvedPath: filePath };
473499
}
474-
throw error;
500+
throw withSrcContext(error);
475501
}
476502
assertAssetMediaTypeProfile(tagName === "video" ? "video" : "audio", profile, elementIdentity);
477503

478504
let metadata: { durationSeconds: number };
479505
if (tagName === "video") {
480-
metadata = await extractMediaMetadata(filePath);
506+
try {
507+
metadata = await extractMediaMetadata(filePath);
508+
} catch (error) {
509+
throw withSrcContext(error);
510+
}
481511
} else {
482512
try {
483513
metadata = await extractAudioMetadata(filePath);

0 commit comments

Comments
 (0)