fix(transcode): per-invocation context — stops goroutine leak

Production goroutine dump on r4dio after 3 days uptime:

  1052 select (mirrorTranscodeMetadata)
       ↑ leaked
  total 1073, RSS 777 MB (baseline: ~45 goroutines, 44 MB)

performTranscode spawned mirrorTranscodeMetadata with the outer
runTranscoder context. That ctx is the transcoder's lifetime
context — only cancelled when the operator stops the transcoder.
So every source disconnect / reconnect cycle (~650/day on this
host based on robodj's reconnect pattern) ran another retry of
performTranscode, which spawned another mirror goroutine whose
ctx was never cancelled. The OLD mirror kept ticking forever.
After three days × ~600 reconnects × ~9 transcoders = ~16k
leaked goroutines worth — production showed 1052 actually
accumulated (the rest had presumably been killed by source
shutdowns earlier).

Each leaked goroutine kept references to its `input`/`output`
*Stream and a `*time.Ticker`. ~1 KB live state × 1052 plus
runtime stack overhead = the >700 MB we observed (Go stacks
default to 8 KB; many will have grown larger over their
lifetime).

Fix: derive a per-invocation child context in performTranscode,
defer-cancel it. Pass it to mirrorTranscodeMetadata, EncodeMP3,
EncodeOpus, and DecoderHub.Acquire so all spawned work tied to
this performTranscode call dies when performTranscode returns.
The outer runTranscoder ctx still controls the whole transcoder
lifetime; the new runCtx is just one retry-loop iteration.

Author: DatanoiseTV

relay/transcode.go

@@ -140,13 +140,27 @@ func (tm *TranscoderManager) safePerformTranscode(ctx context.Context, inst *Tra
 }
 
 func (tm *TranscoderManager) performTranscode(ctx context.Context, inst *TranscoderInstance) {
+	// Per-invocation child context. Cancelled when this function
+	// returns so any goroutine we spawn (mirrorTranscodeMetadata
+	// most notably) exits along with the encode loop instead of
+	// leaking until the parent transcoder is torn down.
+	//
+	// Production goroutine dump showed >1000 mirrorTranscodeMetadata
+	// goroutines accumulated because each source disconnect /
+	// reconnect cycle spawned a fresh one tied to the outer ctx
+	// (which only cancels on Stop, not on encode-loop return).
+	// With ~600 reconnect cycles × N transcoders, the leak filled
+	// the goroutine table and pushed RSS from ~44 MB to >800 MB.
+	runCtx, runCancel := context.WithCancel(ctx)
+	defer runCancel()
+
 	// 1. Acquire a shared decoder for this input. The first
 	//    transcoder per input mount kicks off the underlying
 	//    decoder + PCM fanout pump; subsequent transcoders attach
 	//    to the existing PCM stream. Same-input encoders therefore
 	//    share one decode pass instead of running N redundantly.
 	subID := fmt.Sprintf("transcoder-%s", inst.Config.Name)
-	pcmReader, decoderRate, releaseDecoder, err := tm.hub.Acquire(ctx, inst.Config.InputMount, subID)
+	pcmReader, decoderRate, releaseDecoder, err := tm.hub.Acquire(runCtx, inst.Config.InputMount, subID)
 	if err != nil {
 		logger.L.Errorw("Transcoder: failed to acquire shared decoder",
 			"name", inst.Config.Name, "input", inst.Config.InputMount, "error", err)
@@ -192,7 +206,7 @@ func (tm *TranscoderManager) performTranscode(ctx context.Context, inst *Transco
 	output.mu.Unlock()
 
 	if input != nil {
-		go mirrorTranscodeMetadata(ctx, input, output)
+		go mirrorTranscodeMetadata(runCtx, input, output)
 	}
 
 	// pcmReader is an io.Reader producing S16LE stereo PCM at
@@ -216,7 +230,7 @@ func (tm *TranscoderManager) performTranscode(ctx context.Context, inst *Transco
 		if sr != decoder.SampleRate() {
 			pcm = NewLinearResampler(decoder, decoder.SampleRate(), sr)
 		}
-		EncodeMP3(ctx, tm.relay, output, pcm, inst.Config.Bitrate, &inst.BytesEncoded, false, sr)
+		EncodeMP3(runCtx, tm.relay, output, pcm, inst.Config.Bitrate, &inst.BytesEncoded, false, sr)
 	} else if inst.Config.Format == "opus" {
 		output.mu.Lock()
 		output.ContentType = "audio/ogg"
@@ -233,7 +247,7 @@ func (tm *TranscoderManager) performTranscode(ctx context.Context, inst *Transco
 				"to", 48000,
 			)
 		}
-		EncodeOpus(ctx, tm.relay, output, pcm, inst.Config.Bitrate, &inst.BytesEncoded, false,
+		EncodeOpus(runCtx, tm.relay, output, pcm, inst.Config.Bitrate, &inst.BytesEncoded, false,
 			OpusEncoderSettings{
 				Application: inst.Config.OpusApplication,
 				VBR:         inst.Config.OpusVBR,