feat: add ab session names to logging SOFIE-213

Author: Julusian

packages/corelib/src/dataModel/RundownPlaylist.ts

@@ -31,6 +31,7 @@ export interface ABSessionInfo {
 
 export interface ABSessionAssignment {
 	sessionId: string
+	sessionName: string
 	playerId: number | string
 	lookahead: boolean // purely informational for debugging
 }

packages/job-worker/src/playout/abPlayback/abPlaybackResolver.ts

@@ -4,6 +4,7 @@ import * as _ from 'underscore'
 
 export interface SessionRequest {
 	readonly id: string
+	readonly name: string
 	readonly start: number
 	readonly end: number | undefined
 	readonly optional?: boolean
@@ -14,6 +15,7 @@ export interface SessionRequest {
 
 export interface FailedSession {
 	id: string
+	name: string
 	pieceNames: string[]
 }
 
@@ -318,9 +320,9 @@ export function resolveAbAssignmentsFromRequests(
 			if (req.lookaheadRank !== undefined) {
 				// ignore
 			} else if (req.optional) {
-				res.failedOptional.push({ id: req.id, pieceNames: req.pieceNames })
+				res.failedOptional.push({ id: req.id, name: req.name, pieceNames: req.pieceNames })
 			} else {
-				res.failedRequired.push({ id: req.id, pieceNames: req.pieceNames })
+				res.failedRequired.push({ id: req.id, name: req.name, pieceNames: req.pieceNames })
 			}
 		}
 	}

packages/job-worker/src/playout/abPlayback/abPlaybackSessions.ts

@@ -44,6 +44,7 @@ export function calculateSessionTimeRanges(
 				// This session is already known, so extend the session to cover all the pieces
 				sessionRequests[sessionId] = {
 					id: sessionId,
+					name: session.sessionName,
 					start: Math.min(val.start, start),
 					end: val.end === undefined || end === undefined ? undefined : Math.max(val.end, end),
 					optional: val.optional && (session.optional ?? false),
@@ -55,6 +56,7 @@ export function calculateSessionTimeRanges(
 				// New session
 				sessionRequests[sessionId] = {
 					id: sessionId,
+					name: session.sessionName,
 					start,
 					end,
 					optional: session.optional ?? false,
@@ -69,7 +71,10 @@ export function calculateSessionTimeRanges(
 	const result = _.compact(Object.values<SessionRequest | undefined>(sessionRequests))
 
 	// Include lookaheads, as they dont have pieces
-	const groupedLookaheadMap = new Map<string, Array<OnGenerateTimelineObj<TSR.TSRTimelineContent>>>()
+	const groupedLookaheadMap = new Map<
+		string,
+		{ name: string; objs: Array<OnGenerateTimelineObj<TSR.TSRTimelineContent>> }
+	>()
 	for (const obj of timelineObjects) {
 		if (
 			!!obj.isLookahead &&
@@ -82,16 +87,20 @@ export function calculateSessionTimeRanges(
 			for (const session of obj.abSessions) {
 				if (session.poolName === poolName) {
 					const sessionId = abSessionHelper.getTimelineObjectAbSessionId(obj, session)
-					if (sessionId) {
-						const existing = groupedLookaheadMap.get(sessionId)
-						groupedLookaheadMap.set(sessionId, existing ? [...existing, obj] : [obj])
+					if (!sessionId) continue
+
+					const existing = groupedLookaheadMap.get(sessionId)
+					if (existing) {
+						existing.objs.push(obj)
+					} else {
+						groupedLookaheadMap.set(sessionId, { name: session.sessionName, objs: [obj] })
 					}
 				}
 			}
 		}
 	}
 
-	const groupedLookahead = Array.from(groupedLookaheadMap.entries()).map(([id, objs]) => ({ objs, id }))
+	const groupedLookahead = Array.from(groupedLookaheadMap.entries()).map(([id, info]) => ({ id, ...info }))
 	const sortedLookaheadGroups = _.sortBy(groupedLookahead, (grp) => {
 		// Find the highest priority of the objects
 		const r = _.max(_.pluck(grp.objs, 'priority')) || -900
@@ -102,6 +111,7 @@ export function calculateSessionTimeRanges(
 		if (!sessionRequests[grp.id]) {
 			result.push({
 				id: grp.id,
+				name: grp.name,
 				start: Number.MAX_SAFE_INTEGER, // Distant future
 				end: undefined,
 				lookaheadRank: i + 1, // This is so that we can easily work out which to use first

packages/job-worker/src/playout/abPlayback/applyAssignments.ts

@@ -35,24 +35,28 @@ export function applyAbPlayerObjectAssignments(
 	poolName: string
 ): ABSessionAssignments {
 	const newAssignments: ABSessionAssignments = {}
-	const persistAssignment = (sessionId: string, playerId: AbPlayerId, lookahead: boolean): void => {
+	const persistAssignment = (session: ABSessionAssignment): void => {
 		// Track the assignment, so that the next onTimelineGenerate can try to reuse the same session
-		if (newAssignments[sessionId]) {
+		if (newAssignments[session.sessionId]) {
 			// TODO - warn?
 		}
-		newAssignments[sessionId] = { sessionId, playerId, lookahead }
+		newAssignments[session.sessionId] = session
 	}
 
 	// collect objects by their sessionId
-	const groupedObjectsMap = new Map<string, Array<OnGenerateTimelineObjExt>>()
+	const groupedObjectsMap = new Map<string, { name: string; objs: Array<OnGenerateTimelineObjExt> }>()
 	for (const obj of timelineObjs) {
 		if (obj.abSessions && obj.pieceInstanceId) {
 			for (const session of obj.abSessions) {
 				if (session.poolName === poolName) {
 					const sessionId = abSessionHelper.getTimelineObjectAbSessionId(obj, session)
-					if (sessionId) {
-						const existing = groupedObjectsMap.get(sessionId)
-						groupedObjectsMap.set(sessionId, existing ? [...existing, obj] : [obj])
+					if (!sessionId) continue
+
+					const existing = groupedObjectsMap.get(sessionId)
+					if (existing) {
+						existing.objs.push(obj)
+					} else {
+						groupedObjectsMap.set(sessionId, { name: session.sessionName, objs: [obj] })
 					}
 				}
 			}
@@ -63,7 +67,7 @@ export function applyAbPlayerObjectAssignments(
 	const unexpectedSessions: string[] = []
 
 	// Apply the known assignments
-	for (const [sessionId, objs] of groupedObjectsMap.entries()) {
+	for (const [sessionId, info] of groupedObjectsMap.entries()) {
 		if (sessionId === 'undefined') continue
 
 		const matchingAssignment = resolvedAssignments.find((req) => req.id === sessionId)
@@ -76,24 +80,34 @@ export function applyAbPlayerObjectAssignments(
 						abConfiguration,
 						poolName,
 						matchingAssignment.playerId,
-						objs
+						info.objs
 					)
 				)
-				persistAssignment(sessionId, matchingAssignment.playerId, !!matchingAssignment.lookaheadRank)
+				persistAssignment({
+					sessionId,
+					sessionName: matchingAssignment.name,
+					playerId: matchingAssignment.playerId,
+					lookahead: !!matchingAssignment.lookaheadRank,
+				})
 			} else {
 				// A warning will already have been raised about this having no player
 			}
 		} else {
 			// This is a group that shouldn't exist, so are likely a bug. There isnt a lot we can do beyond warn about the issue
-			unexpectedSessions.push(`${sessionId}(${objs.map((obj) => obj.id).join(',')})`)
+			unexpectedSessions.push(`${sessionId}(${info.objs.map((obj) => obj.id).join(',')})`)
 
 			// If there was a previous assignment, hopefully that is better than nothing
 			const prev = previousAssignmentMap?.[sessionId]
 			if (prev) {
 				failedObjects.push(
-					...updateObjectsToAbPlayer(blueprintContext, abConfiguration, poolName, prev.playerId, objs)
+					...updateObjectsToAbPlayer(blueprintContext, abConfiguration, poolName, prev.playerId, info.objs)
 				)
-				persistAssignment(sessionId, prev.playerId, false)
+				persistAssignment({
+					sessionId,
+					sessionName: '?',
+					playerId: prev.playerId,
+					lookahead: false,
+				})
 			}
 		}
 	}
@@ -110,7 +124,7 @@ export function applyAbPlayerObjectAssignments(
 	for (const assignment of Object.values<ABSessionAssignment | undefined>(newAssignments)) {
 		if (!assignment) continue
 		logger.silly(
-			`ABPlayback: Assigned session "${poolName}"-"${assignment.sessionId}" to player "${assignment.playerId}" (lookahead: ${assignment.lookahead})`
+			`ABPlayback: Assigned session "${poolName}"-"${assignment.sessionId}" (${assignment.sessionName}) to player "${assignment.playerId}" (lookahead: ${assignment.lookahead})`
 		)
 	}
 

packages/job-worker/src/playout/abPlayback/index.ts

@@ -69,7 +69,7 @@ export function applyAbPlaybackForTimeline(
 		for (const assignment of Object.values<ABSessionAssignment | undefined>(assignments)) {
 			if (assignment) {
 				logger.silly(
-					`ABPlayback: Previous assignment "${pool}"-"${assignment.sessionId}" to player "${assignment.playerId}"`
+					`ABPlayback: Previous assignment "${pool}"-"${assignment.sessionId}" (${assignment.sessionName}) to player "${assignment.playerId}"`
 				)
 			}
 		}
@@ -110,14 +110,16 @@ export function applyAbPlaybackForTimeline(
 
 		for (const assignment of Object.values<SessionRequest>(assignments.requests)) {
 			logger.silly(
-				`ABPlayback resolved session "${poolName}"-"${assignment.id}" to player "${
+				`ABPlayback resolved session "${poolName}"-"${assignment.id}" (${assignment.name}) to player "${
 					assignment.playerId
 				}" (${JSON.stringify(assignment)})`
 			)
 		}
 		for (const failedSession of assignments.failedRequired) {
 			const uniqueNames = _.uniq(failedSession.pieceNames).join(', ')
-			logger.warn(`ABPlayback failed to assign session for "${poolName}"-"${failedSession.id}": ${uniqueNames}`)
+			logger.warn(
+				`ABPlayback failed to assign session for "${poolName}"-"${failedSession.id}" (${failedSession.name}): ${uniqueNames}`
+			)
 
 			// Ignore lookahead
 			if (failedSession.pieceNames.length === 0) continue
@@ -134,7 +136,7 @@ export function applyAbPlaybackForTimeline(
 		for (const failedSession of assignments.failedOptional) {
 			const uniqueNames = _.uniq(failedSession.pieceNames).join(', ')
 			logger.info(
-				`ABPlayback failed to assign optional session for "${poolName}"-"${failedSession.id}": ${uniqueNames}`
+				`ABPlayback failed to assign optional session for "${poolName}"-"${failedSession.id}" (${failedSession.name}): ${uniqueNames}`
 			)
 
 			// Ignore lookahead