Reuse per-thread MemoryStream/Utf8JsonWriter in EventSourceLogger.ToJson

[mangod9]

Reduces per-log-event allocations in EventSourceLogger.ToJson, which runs on every logged event when the JsonMessage keyword is enabled (e.g. dotnet-trace collection).

Problem

ToJson allocated a new MemoryStream(), a new Utf8JsonWriter(), and their backing buffers on every call.

Change

Reuse a [ThreadStatic] MemoryStream + Utf8JsonWriter, resetting them per call via MemoryStream.SetLength(0) + Utf8JsonWriter.Reset(stream). The only remaining allocation is the returned JSON string. The approach uses only APIs available on all target frameworks (incl. netstandard2.0/net462).

Measurements (per-call allocation A/B, isolated harness)

props	before B/call	after B/call	reduction	speedup
0	824	32	96%	1.56x
2	912	120	87%	1.99x
6	960	168	82%	1.21x

The residual "after" bytes are only the returned result string.

Validation

• Builds clean across all TFMs (net11/net10/netstandard2.0/net462), 0 warnings.
• Microsoft.Extensions.Logging.EventSource unit tests pass (26/26). The JsonMessage-keyword tests parse and validate the emitted JSON, confirming byte-identical output.

Note

This pull request was generated with the assistance of GitHub Copilot.

[azure-pipelines]

Azure Pipelines:
Successfully started running 3 pipeline(s).
13 pipeline(s) were filtered out due to trigger conditions.
There may be pipelines that require an authorized user to comment /azp run to run.

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-extensions-logging
See info in area-owners.md if you want to be subscribed.

[Copilot]

Pull request overview

This PR optimizes Microsoft.Extensions.Logging.EventSource’s JSON payload generation path by reusing per-thread serialization state in EventSourceLogger.ToJson, reducing per-event allocations when JSON logging is enabled.

Changes:

• Introduces [ThreadStatic] caching for a MemoryStream and Utf8JsonWriter used by EventSourceLogger.ToJson.
• Resets the cached instances per call via MemoryStream.SetLength(0) and Utf8JsonWriter.Reset(stream).
• Simplifies UTF-8 decoding by directly producing the JSON string from the stream buffer (with a fallback to ToArray()).

[tarekgh]

Two notes on the reworked ToJson. The thread-static reuse itself looks correct: it's fully synchronous, per-thread, and the buffer is never live across a reentrant call, so there's no corruption risk. The per-thread buffer retention is the one worth addressing.

[tarekgh]

The per-thread MemoryStream (and the writer's internal buffer) grows to the largest event ever serialized on this thread and is never shrunk, so a single large property value permanently inflates steady-state memory on long-lived thread-pool threads. ConsoleLogger handles the same pattern by capping its thread-static StringBuilder at 1024 (ConsoleLogger.cs). Suggest capping the stream the same way before returning:

Suggested change

	return result;
	if (stream.Capacity > 1024)
	{
	stream.Capacity = 1024;
	}
	return result;

[tarekgh]

Minor: result just wraps the ternary and could be a direct return. Note that if you take the capacity-cap suggestion on the return line, keep the local (you need the string in hand before resetting Capacity); otherwise this can just be return stream.TryGetBuffer(...) ? ... : ...;.