DocumentClientEventListener.cs

/*
Usage:
 client = new DocumentClient(new Uri(Endpoint), Key);
 _clientEventListener = new DocumentClientEventListener(client);

 CreateDatabaseIfNotExistsAsync().Wait();
 CreateCollectionIfNotExistsAsync().Wait();

 _clientEventListener.Initialize();
 _clientEventListener.SendRequest += (sender, message) =>
 {
    Console.WriteLine($"{message.RequestUri.ToString()} => {message.Content?.ReadAsStringAsync().Result}");
 };
*/
 namespace CosmosDBProfilerPOC
 {
    public class DocumentClientEventListener
    {
        private readonly DocumentClient _client;
        private EventListenerHttpClientHandler _eventListener;
        private HttpClient _httpClient;
        private static readonly Type DocumentClientType = typeof(DocumentClient);
        private static readonly FieldInfo StoreModelField;

        static DocumentClientEventListener()
        {
            StoreModelField = DocumentClientType.GetField("storeModel", BindingFlags.Instance | BindingFlags.NonPublic);
        }

        public DocumentClientEventListener(DocumentClient client)
        {
            _client = client;
        }

        public void Initialize()
        {
            //TODO: no error handling here, need to add some...

            var storeModel = StoreModelField.GetValue(_client);

            var httpClientField = storeModel.GetType().GetField("httpClient", BindingFlags.Instance | BindingFlags.NonPublic);
            
            _httpClient = (HttpClient)httpClientField.GetValue(storeModel);
            var httpMessageHandlerField = _httpClient.GetType().BaseType.GetField("_handler", BindingFlags.Instance | BindingFlags.NonPublic);

            _eventListener = new EventListenerHttpClientHandler(_httpClient);
                
            httpMessageHandlerField.SetValue(_httpClient, _eventListener);
        }

        public event EventHandler<HttpRequestMessage> SendRequest
        {
            add => _eventListener.SendRequest += value;
            remove => _eventListener.SendRequest -= value;
        }


        public class EventListenerHttpClientHandler : HttpClientHandler
        {
            private readonly HttpClient _httpClient;

            public EventListenerHttpClientHandler(HttpClient httpClient) => _httpClient = httpClient;

            public event EventHandler<HttpRequestMessage> SendRequest;

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                OnSendRequest(request);
                return base.SendAsync(request, cancellationToken);
            }

            //TODO: add error handling here too?
            protected virtual void OnSendRequest(HttpRequestMessage request) => SendRequest?.Invoke(_httpClient,request);
        }
    }
}