chore: import upstream snapshot with attribution

dotnet/tests/Microsoft.Agents.AI.DurableTask.IntegrationTests/Logging/LogEntry.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Agents.AI.DurableTask.IntegrationTests.Logging;
+
+internal sealed class LogEntry(
+    string category,
+    LogLevel level,
+    EventId eventId,
+    Exception? exception,
+    string message,
+    object? state,
+    IReadOnlyList<KeyValuePair<string, object?>> contextProperties)
+{
+    public string Category { get; } = category;
+
+    public DateTime Timestamp { get; } = DateTime.Now;
+
+    public EventId EventId { get; } = eventId;
+
+    public LogLevel LogLevel { get; } = level;
+
+    public Exception? Exception { get; } = exception;
+
+    public string Message { get; } = message;
+
+    public object? State { get; } = state;
+
+    public IReadOnlyList<KeyValuePair<string, object?>> ContextProperties { get; } = contextProperties;
+
+    public override string ToString()
+    {
+        string properties = this.ContextProperties.Count > 0
+            ? $"[{string.Join(", ", this.ContextProperties.Select(kvp => $"{kvp.Key}={kvp.Value}"))}] "
+            : string.Empty;
+
+        string eventName = this.EventId.Name ?? string.Empty;
+        string output = $"{this.Timestamp:o} [{this.Category}] {eventName} {properties}{this.Message}";
+
+        if (this.Exception is not null)
+        {
+            output += Environment.NewLine + this.Exception;
+        }
+
+        return output;
+    }
+}

dotnet/tests/Microsoft.Agents.AI.DurableTask.IntegrationTests/Logging/TestLogger.cs

@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Concurrent;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Agents.AI.DurableTask.IntegrationTests.Logging;
+
+internal sealed class TestLogger(string category, ITestOutputHelper output) : ILogger
+{
+    private readonly string _category = category;
+    private readonly ITestOutputHelper _output = output;
+    private readonly ConcurrentQueue<LogEntry> _entries = new();
+
+    public IReadOnlyCollection<LogEntry> GetLogs() => this._entries;
+
+    public void ClearLogs() => this._entries.Clear();
+
+    IDisposable? ILogger.BeginScope<TState>(TState state) => null;
+
+    bool ILogger.IsEnabled(LogLevel logLevel) => true;
+
+    void ILogger.Log<TState>(
+        LogLevel logLevel,
+        EventId eventId,
+        TState state,
+        Exception? exception,
+        Func<TState, Exception?, string> formatter)
+    {
+        LogEntry entry = new(
+            category: this._category,
+            level: logLevel,
+            eventId: eventId,
+            exception: exception,
+            message: formatter(state, exception),
+            state: state,
+            contextProperties: []);
+
+        this._entries.Enqueue(entry);
+
+        try
+        {
+            this._output.WriteLine(entry.ToString());
+        }
+        catch (InvalidOperationException)
+        {
+            // Expected when tests are shutting down
+        }
+    }
+}

dotnet/tests/Microsoft.Agents.AI.DurableTask.IntegrationTests/Logging/TestLoggerProvider.cs

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Concurrent;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Agents.AI.DurableTask.IntegrationTests.Logging;
+
+internal sealed class TestLoggerProvider(ITestOutputHelper output) : ILoggerProvider
+{
+    private readonly ITestOutputHelper _output = output ?? throw new ArgumentNullException(nameof(output));
+    private readonly ConcurrentDictionary<string, TestLogger> _loggers = new(StringComparer.OrdinalIgnoreCase);
+
+    public bool TryGetLogs(string category, out IReadOnlyCollection<LogEntry> logs)
+    {
+        if (this._loggers.TryGetValue(category, out TestLogger? logger))
+        {
+            logs = logger.GetLogs();
+            return true;
+        }
+
+        logs = [];
+        return false;
+    }
+
+    public IReadOnlyCollection<LogEntry> GetAllLogs()
+    {
+        return this._loggers.Values
+            .OfType<TestLogger>()
+            .SelectMany(logger => logger.GetLogs())
+            .ToList()
+            .AsReadOnly();
+    }
+
+    public void Clear()
+    {
+        foreach (TestLogger logger in this._loggers.Values.OfType<TestLogger>())
+        {
+            logger.ClearLogs();
+        }
+    }
+
+    ILogger ILoggerProvider.CreateLogger(string categoryName)
+    {
+        return this._loggers.GetOrAdd(categoryName, _ => new TestLogger(categoryName, this._output));
+    }
+
+    void IDisposable.Dispose()
+    {
+        // no-op
+    }
+}