feat: Report event source headers on open.

src/LaunchDarkly.EventSource/EventSource.cs

@@ -301,10 +301,10 @@ private async Task ConnectToEventSourceAsync(CancellationToken cancellationToken
             _eventDataUtf8ByteBuffer = null;
 
             var svc = GetEventSourceService(_configuration);
-            
+
             svc.ConnectionOpened += (o, e) => {
                 _lastSuccessfulConnectionTime = DateTime.Now;
-                SetReadyState(ReadyState.Open, OnOpened);
+                SetReadyState(ReadyState.Open, OnOpened, e.Headers);
             };
             svc.ConnectionClosed += (o, e) => { SetReadyState(ReadyState.Closed, OnClosed); };
 
@@ -321,7 +321,7 @@ private void Close(ReadyState state)
             _logger.Debug("Close({0}) - state was {1}", state, ReadyState);
             SetReadyState(state, OnClosed);
         }
-        
+
         private void ProcessResponseLineString(string content)
         {
             if (content == null)
@@ -353,20 +353,22 @@ private void ProcessResponseLineUtf8(Utf8ByteSpan content)
         }
 
 
-        private void SetReadyState(ReadyState state, Action<StateChangedEventArgs> action = null)
+        private void SetReadyState(ReadyState state, Action<StateChangedEventArgs> action = null,
+            IEnumerable<KeyValuePair<string, IEnumerable<string>>> headers = null)
         {
             lock (this)
             {
                 if (_readyState == state || _readyState == ReadyState.Shutdown)
                 {
                     return;
                 }
+
                 _readyState = state;
             }
 
             if (action != null)
             {
-                action(new StateChangedEventArgs(state));
+                action(new StateChangedEventArgs(state, headers));
             }
         }
 

src/LaunchDarkly.EventSource/EventSourceOpenedEventArgs.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+
+namespace LaunchDarkly.EventSource
+{
+    /// <summary>
+    /// Event arguments for the EventSourceService opened event.
+    /// </summary>
+    internal class EventSourceOpenedEventArgs: EventArgs
+    {
+        /// <summary>
+        /// Construct new event arguments.
+        /// </summary>
+        /// <param name="headers">headers from the HTTP response</param>
+        public EventSourceOpenedEventArgs(IEnumerable<KeyValuePair<string, IEnumerable<string>>> headers)
+        {
+            Headers = headers;
+        }
+
+        /// <summary>
+        /// Response headers from the underlying HTTP request.
+        /// </summary>
+        public IEnumerable<KeyValuePair<string,IEnumerable<string>>> Headers { get; }
+    }
+}

src/LaunchDarkly.EventSource/EventSourceService.cs

@@ -37,7 +37,7 @@ internal class EventSourceService
         /// <summary>
         /// Occurs when the connection to the EventSource API has been opened.
         /// </summary>
-        public event EventHandler<EventArgs> ConnectionOpened;
+        public event EventHandler<EventSourceOpenedEventArgs> ConnectionOpened;
         /// <summary>
         /// Occurs when the connection to the EventSource API has been closed.
         /// </summary>
@@ -108,7 +108,8 @@ CancellationToken cancellationToken
                         throw new EventSourceServiceCancelledException(
                             string.Format(Resources.ErrorWrongEncoding, encoding.HeaderName));
                     }
-                    OnConnectionOpened();
+
+                    OnConnectionOpened(response.Headers);
 
                     if (_configuration.PreferDataAsUtf8Bytes)
                     {
@@ -257,9 +258,9 @@ private void ValidateResponse(HttpResponseMessage response)
             }
         }
 
-        private void OnConnectionOpened()
+        private void OnConnectionOpened(HttpHeaders headers)
         {
-            ConnectionOpened?.Invoke(this, EventArgs.Empty);
+            ConnectionOpened?.Invoke(this, new EventSourceOpenedEventArgs(headers));
         }
 
         private void OnConnectionClosed()

src/LaunchDarkly.EventSource/StateChangedEventArgs.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 
 namespace LaunchDarkly.EventSource
 {
@@ -16,13 +17,23 @@ public class StateChangedEventArgs : EventArgs
         /// </value>
         public ReadyState ReadyState { get; }
 
+        /// <summary>
+        /// Get the response headers. Only populated for <see cref="ReadyState.Open"/>.
+        /// <value>
+        /// A collection of header values when the ReadyState is Open, or null.
+        /// </value>
+        /// </summary>
+        public IEnumerable<KeyValuePair<string,IEnumerable<string>>> Headers { get; }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="StateChangedEventArgs"/> class.
         /// </summary>
         /// <param name="readyState">One of the <see cref="EventSource.ReadyState"/> values, which represents the state of the EventSource connection.</param>
-        public StateChangedEventArgs(ReadyState readyState)
+        /// <param name="headers">Response headers when the <see cref="StateChangedEventArgs.ReadyState"/> is <see cref="ReadyState.Open"/>. Otherwise null.</param>
+        public StateChangedEventArgs(ReadyState readyState, IEnumerable<KeyValuePair<string,IEnumerable<string>>> headers = null)
         {
             ReadyState = readyState;
+            Headers = headers;
         }
     }
-}
+}

test/LaunchDarkly.EventSource.Tests/EventSourceHttpBehaviorTest.cs

@@ -165,6 +165,36 @@
             }
         }
 
+        [Fact]
+        public async void OpenedEventIncludesHeaders()
+        {
+            var taskComplete = new TaskCompletionSource<bool>();
+
+            Handler streamHandler = Handlers.StartChunks("text/event-stream")
+                .Then(async ctx =>
+                {
+                    await Handlers.WriteChunkString("data:potato\n\n")(ctx);
+                    await taskComplete.Task;
+                });
+            using (var server = HttpServer.Start(streamHandler))
+            {
+                using (var es = MakeEventSource(server.Uri))
+                {
+                    es.Opened += (sender, args) =>
+                    {
+                        // The transfer-encoding header should always be present for an SSE stream.
+                        taskComplete.SetResult(
+                            args.Headers.FirstOrDefault(item => string.Equals(item.Key, "transfer-encoding", StringComparison.OrdinalIgnoreCase)).Value != null);
+                    };
+                    _ = Task.Run(es.StartAsync);
+
+                    await taskComplete.Task;
+                }
+            }
+
+            Assert.True(taskComplete.Task.Result);
+        }
+
         [Fact]
         public void ReceiveEventStreamInChunks()
         {