Bug fixes

Author: normj

Libraries/src/Amazon.Lambda.Core/ResponseStreaming/HttpResponseStreamPrelude.cs

@@ -1,6 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 #if NET8_0_OR_GREATER
+using System;
 using System.Collections.Generic;
 using System.Net;
 using System.Runtime.Versioning;
@@ -82,6 +83,11 @@ internal byte[] ToByteArray()
                 writer.WriteEndObject();
             }
 
+            if (string.Equals(Environment.GetEnvironmentVariable("LAMBDA_NET_SERIALIZER_DEBUG"), "true", StringComparison.OrdinalIgnoreCase))
+            {
+                LambdaLogger.Log(LogLevel.Information, "HTTP Response Stream Prelude JSON: {Prelude}", System.Text.Encoding.UTF8.GetString(bufferWriter.WrittenSpan));
+            }
+
             return bufferWriter.WrittenSpan.ToArray();
         }
     }

Libraries/src/Amazon.Lambda.RuntimeSupport/Bootstrap/ResponseStreaming/ResponseStream.cs

@@ -82,15 +82,17 @@ internal async Task SetHttpOutputStreamAsync(Stream httpOutputStream, Cancellati
             // where a handler WriteAsync that is already waiting on the semaphore could
             // sneak in and write body data before the prelude, causing intermittent
             // "Failed to parse prelude JSON" errors from API Gateway.
+            //
+            // Note: we intentionally do NOT check ThrowIfCompletedOrError() here.
+            // SetHttpOutputStreamAsync is infrastructure setup called by RawStreamingHttpClient,
+            // not a handler write. For fast-completing responses (e.g. Results.Json),
+            // LambdaBootstrap may call MarkCompleted() before the TCP connection is established
+            // and this method is called. The prelude still needs to be written to the wire
+            // so the response is properly framed.
             if (_prelude?.Length > 0)
             {
                 _logger.LogDebug($"Writing prelude of {_prelude.Length} bytes to HTTP stream.");
 
-                lock (_lock)
-                {
-                    ThrowIfCompletedOrError();
-                }
-
                 var combinedLength = _prelude.Length + PreludeDelimiter.Length;
                 var combined = ArrayPool<byte>.Shared.Rent(combinedLength);
                 try
@@ -152,7 +154,12 @@ public async Task WriteAsync(byte[] buffer, int offset, int count, CancellationT
 
                 lock (_lock)
                 {
-                    ThrowIfCompletedOrError();
+                    // Only throw on error, not on completed. For buffered ASP.NET Core responses
+                    // (e.g. Results.Json), the pipeline completes and LambdaBootstrap calls
+                    // MarkCompleted() before the pre-start buffer has been flushed to the wire.
+                    // The buffered data still needs to be written even after MarkCompleted.
+                    if (_hasError)
+                        throw new InvalidOperationException("Cannot write to a stream after an error has been reported.");
                     _bytesWritten += count;
                 }
 

Libraries/test/Amazon.Lambda.RuntimeSupport.Tests/Amazon.Lambda.RuntimeSupport.UnitTests/ResponseStreamTests.cs

@@ -140,14 +140,18 @@ public async Task ReportErrorAsync_ReleasesCompletionSignal()
         }
 
         [Fact]
-        public async Task WriteAsync_AfterMarkCompleted_Throws()
+        public async Task WriteAsync_AfterMarkCompleted_StillSucceeds()
         {
-            var (stream, _) = await CreateWiredStream();
+            var (stream, output) = await CreateWiredStream();
             await stream.WriteAsync(new byte[] { 1 }, 0, 1);
             stream.MarkCompleted();
 
-            await Assert.ThrowsAsync<InvalidOperationException>(
-                () => stream.WriteAsync(new byte[] { 2 }, 0, 1));
+            // Writes after MarkCompleted are allowed — buffered ASP.NET Core responses
+            // (e.g. Results.Json) may flush pre-start buffer data after the pipeline
+            // completes and LambdaBootstrap calls MarkCompleted.
+            await stream.WriteAsync(new byte[] { 2 }, 0, 1);
+
+            Assert.Equal(new byte[] { 1, 2 }, output.ToArray());
         }
 
         [Fact]