fix data-channel-write error wrap to preserve context cancellation identity

pkg/handlers/default.go:139 wrapped the CancellableWrite failure with %v,
which dropped context.DeadlineExceeded / context.Canceled from the
errors.Is chain on the returned ErrProcessingFatal. The downstream
measureLatencyAndHandleErrors classifier uses
errors.Is(err, context.DeadlineExceeded) to increment the timeout metric
and apply the "error processing chunk" framing; with %v that branch was
unreachable for this failure path, causing the timeout metric to
under-count and the chunk-processing framing to be missing.

Switching to %w preserves both the outer ErrProcessingFatal wrap (so
isFatal still classifies correctly) and the inner ctx.Err() identity
(so the timeout classifier fires). Multiple %w verbs in a single
fmt.Errorf are supported on Go 1.20+; this repo is on Go 1.24.

Same shape as #4929's fix at line 137 but feeds a different
classifier (metric correctness rather than control flow).

Adds a regression test that constructs a dead context, drives a
chunk-error through handleNonArchiveContent against an unbuffered
output channel to force CancellableWrite to fail, and asserts both
the outer ErrProcessingFatal wrap and the inner ctx.Err() identity
are preserved for both DeadlineExceeded and Canceled.

Author: johnelliott

pkg/handlers/default.go

@@ -136,7 +136,7 @@ func (h *defaultHandler) handleNonArchiveContent(
 			h.metrics.incErrors()
 			dataOrErr.Err = fmt.Errorf("%w: error reading chunk: %v", ErrProcessingWarning, err)
 			if writeErr := common.CancellableWrite(ctx, dataOrErrChan, dataOrErr); writeErr != nil {
-				return fmt.Errorf("%w: error writing to data channel: %v", ErrProcessingFatal, writeErr)
+				return fmt.Errorf("%w: error writing to data channel: %w", ErrProcessingFatal, writeErr)
 			}
 			continue
 		}

pkg/handlers/default_test.go

@@ -1,6 +1,8 @@
 package handlers
 
 import (
+	stdctx "context"
+	"errors"
 	"os"
 	"strings"
 	"testing"
@@ -117,3 +119,66 @@ func TestHandleFileLineNumbers(t *testing.T) {
 		assert.Equal(t, int64(11), results[1].LineNumber, "peek data should not be counted")
 	})
 }
+
+// TestDefaultHandler_DataChannelWriteErrorPreservesIdentity is a regression test
+// for the %v wrap at default.go:139. When CancellableWrite fails because the
+// handler context terminated mid-processing, the returned error must preserve
+// the underlying ctx.Err() identity. measureLatencyAndHandleErrors uses
+// errors.Is(err, context.DeadlineExceeded) to drive the timeout metric and the
+// "error processing chunk" framing; with %v that branch is unreachable for the
+// data-channel write failure path.
+func TestDefaultHandler_DataChannelWriteErrorPreservesIdentity(t *testing.T) {
+	cases := []struct {
+		name    string
+		makeCtx func() (stdctx.Context, stdctx.CancelFunc)
+		want    error
+	}{
+		{
+			name: "DeadlineExceeded preserved through writeErr wrap",
+			makeCtx: func() (stdctx.Context, stdctx.CancelFunc) {
+				return stdctx.WithDeadline(stdctx.Background(), time.Now().Add(-time.Second))
+			},
+			want: stdctx.DeadlineExceeded,
+		},
+		{
+			name: "Canceled preserved through writeErr wrap",
+			makeCtx: func() (stdctx.Context, stdctx.CancelFunc) {
+				ctx, cancel := stdctx.WithCancel(stdctx.Background())
+				cancel()
+				return ctx, cancel
+			},
+			want: stdctx.Canceled,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			deadCtx, cancel := tc.makeCtx()
+			defer cancel()
+			ctx := context.AddLogger(deadCtx)
+
+			// Any non-nil error works here; what matters is that the chunk-error
+			// branch runs and reaches CancellableWrite, which then fails because
+			// ctx is already terminal.
+			chunks := []sources.ChunkResult{sources.NewChunkResultError(errors.New("simulated chunk read failure"))}
+			handler := newDefaultHandler(defaultHandlerType, withChunkReader(mockChunkReader(chunks)))
+
+			reader, err := newFileReader(context.Background(), strings.NewReader("ignored"))
+			require.NoError(t, err)
+			defer reader.Close()
+
+			// Unbuffered channel forces CancellableWrite to consult ctx.Done() and
+			// return ctx.Err() since no reader is draining.
+			dataOrErrChan := make(chan DataOrErr)
+
+			err = handler.handleNonArchiveContent(ctx, newMimeTypeReaderFromFileReader(reader), dataOrErrChan)
+			require.Error(t, err)
+
+			assert.True(t, errors.Is(err, ErrProcessingFatal),
+				"outer ErrProcessingFatal wrap must be preserved so isFatal classifies the failure")
+			assert.True(t, errors.Is(err, tc.want),
+				"inner ctx.Err() must remain inspectable so measureLatencyAndHandleErrors "+
+					"can correctly increment the timeout metric")
+		})
+	}
+}