Azure Cognitive Searchのリクエストのロギング

        // Create a service and index client.
        _serviceClient = new SearchServiceClient(searchServiceName, new SearchCredentials(queryApiKey));
        _indexClient = _serviceClient.Indexes.GetClient("hotels");

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

namespace AzureSearchSample
{
    public class CustomLoggingHttpMessageHandler : DelegatingHandler
    {
        private readonly ILogger _logger;
        private readonly bool _logContent = false;

        public CustomLoggingHttpMessageHandler(ILogger logger, bool logContent)
        {
            if (logger == null)
            {
                throw new ArgumentNullException(nameof(logger));
            }

            this._logger = logger;
            this._logContent = logContent;
        }


        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            } 
            await Log.RequestStart(this._logger, request, this._logContent);
            var stopwatch = new Stopwatch();
            HttpResponseMessage response = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
            stopwatch.Stop();
            await Log.RequestEnd(this._logger, response, stopwatch.Elapsed);

            return response;
        }

        private static class Log
        {
            private static class EventIds
            {
                public static readonly EventId RequestStart = new EventId(100, "RequestStart");
                public static readonly EventId RequestEnd = new EventId(101, "RequestEnd");
            }

            public static async Task RequestStart(ILogger logger, HttpRequestMessage request, bool logContent)
            {
                StringBuilder message = new StringBuilder();
                message.AppendLine($"Sending HTTP request {request.Method} {request.RequestUri}");
                if (logger.IsEnabled(LogLevel.Trace))
                {
                    LogHttpHeaders(message, request.Headers);
                    await LogHttpContent(message, request.Content, logContent);
                    logger.Log(
                        LogLevel.Trace,
                        EventIds.RequestStart,
                        message,
                        null,
                        (state, ex) => state.ToString());
                }
            }

            public static async Task RequestEnd(ILogger logger, HttpResponseMessage response, TimeSpan duration)
            {
                StringBuilder message = new StringBuilder();
                message.AppendLine(
                    $"Recieving HTTP response after {duration.TotalMilliseconds}ms - {response.StatusCode}");
                if (logger.IsEnabled(LogLevel.Trace))
                {
                    LogHttpHeaders(message, response.Headers);
                    await LogHttpContent(message, response.Content, false);
                    logger.Log(
                        LogLevel.Trace,
                        EventIds.RequestEnd,
                        message,
                        null,
                        (state, ex) => state.ToString()
                        );
                }
            }

            private static void LogHttpHeaders(StringBuilder message, HttpHeaders headers)
            {
                if (headers == null) throw new ArgumentNullException(nameof(headers));
                foreach (KeyValuePair<string, IEnumerable<string>> header in headers)
                {
                    foreach (string value in header.Value)
                    {
                        message.AppendLine($"{header.Key}: {value}");
                    }
                }
            }

            private static async Task LogHttpContent(StringBuilder message, HttpContent content,
                bool logContent)
            {
                if (content != null)
                {
                    foreach (KeyValuePair<string,IEnumerable<string>> header in content.Headers)
                    {
                        foreach (string value in header.Value)
                        {
                            message.AppendLine($"{header.Key}: {value}");
                        }
                    }

                    if (logContent)
                    {
                        string contentBody = await content.ReadAsStringAsync();
                        message.AppendLine(contentBody);
                    }
                }
            }
        }
    }
}

        private ISearchIndexClient GetClient(string indexName, params DelegatingHandler[] handlers)
        {
            var rootHandler = _searchServiceClient.HttpMessageHandlers.OfType<HttpClientHandler>().SingleOrDefault();
            var indexClient =
                new SearchIndexClient(_searchServiceClient.SearchServiceName, indexName,
                    _searchServiceClient.SearchCredentials, rootHandler, handlers)
                {
                    SearchDnsSuffix = _searchServiceClient.SearchDnsSuffix
                };

            indexClient.HttpClient.Timeout = _searchServiceClient.HttpClient.Timeout;
            return indexClient;
        }

ServiceClientTracing.IsEnabled = true;
ServiceClientTracing.AddTracingInterceptor(new Log4NetTracingInterceptor());

using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using Microsoft.ApplicationInsights.Channel;
using Microsoft.ApplicationInsights.DataContracts;
using Microsoft.ApplicationInsights.Extensibility;

namespace AzureSearchWebSample.ApplicationInsights
{
    public class HttpRequestInitializer : ITelemetryInitializer
    {
        public void Initialize(ITelemetry telemetry)
        {

            if (!(telemetry is DependencyTelemetry dependency))
            {
                return;
            }

            HttpRequestMessage requestMessage = null;
            HttpRequestHeaders requestHeaders;
            if (dependency.TryGetOperationDetail("HttpRequest", out var details) &&
                details is HttpRequestMessage request)
            {
                requestMessage = request;
                requestHeaders = request.Headers;            
                if (requestMessage.Method == HttpMethod.Post)
                {
                    string contentBody = requestMessage.Content.ReadAsStringAsync().GetAwaiter().GetResult();
                    dependency.Properties.Add("RequestBody",contentBody);
                }
            }
            else if (dependency.TryGetOperationDetail("HttpRequestHeaders", out details) &&
                     details is HttpRequestHeaders headers)
            {
                requestHeaders = headers;
            }
            else
            {
                return;
            }

            foreach (KeyValuePair<string,IEnumerable<string>> header in requestHeaders)
            {
                foreach (string value in header.Value)
                {
                    dependency.Properties.Add(header.Key, value);
                }
            }
            //この実装の場合は出力されなかった。なぜ?
            // if (requestMessage != null && requestMessage.Method == HttpMethod.Post)
            // {
            //     string contentBody = requestMessage.Content.ReadAsStringAsync().GetAwaiter().GetResult();
            //     dependency.Properties.Add("RequestBody",contentBody);
            // }
        }
    }
}