locked
Connection_Dropped_List_Full RRS feed

  • Question

  • User-1104215994 posted

    Hi,

    I checked the C:\Windows\System32\LogFiles\HTTPERR logs. What does it mean? How can I fix this? (IIS 8 , Windows 2012)

    2019-08-08 18:05:06 99.99.999.999 59334 11.1.11.1 1907 HTTP/1.1 POST /api/v2/game/purchase - 3 Connection_Dropped_List_Full EPIN 2019-08-08 18:05:46 99.99.999.999 59801 11.1.11.1 1907 HTTP/1.1 POST /api/v2/game/purchase - 3 Request_Cancelled EPIN

    Sunday, August 11, 2019 6:22 PM

All replies

  • User1724605321 posted

    Hi cenk1536 ,

    You can refer to below article :

    What does Connection_Dropped_List_Full mean

    When you look in the HTTP Error log (c:\Windows\System32\LogFiles\HTTPERR) and see a lot of Connection_Dropped_List_Full error reasons logged, it means that the client has dropped the connection so many times, in a short period, that the log in which the dropped connections are stored has become full. 

    Below related thread is also for your reference :

    https://forums.iis.net/t/1236352.aspx?What+Connection_Dropped_List_Full+in+IIS+Httperr+log+refers+to+ 

    Best Regards,

    Nan Yu

    Monday, August 12, 2019 6:47 AM
  • User-1104215994 posted

    I got this error when I load test with Jmeter.

    Monday, August 12, 2019 1:30 PM
  • User-474980206 posted

    then it means there is bug in the load tester code (it closing the connection before reading the response). probably poorly coded HttpClient code.

    Monday, August 12, 2019 3:55 PM
  • User-1104215994 posted

    <g class="gr_ gr_18 gr-alert gr_gramm gr_inline_cards gr_run_anim Punctuation only-ins replaceWithoutSep" id="18" data-gr-id="18">Hi</g> <g class="gr_ gr_17 gr-alert gr_spell gr_inline_cards gr_run_anim ContextualSpelling ins-del multiReplace" id="17" data-gr-id="17">bruce</g>,

    Do you mean how I call the client?

    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Data.Entity;
    using System.Linq;
    using System.Net;
    using System.Net.Http;
    using System.Threading.Tasks;
    using System.Transactions;
    using AutoMapper;
    using BusinessEntity;
    using BusinessService.Utility;
    using DataModels;
    using Newtonsoft.Json;
    
    namespace BusinessService
    {
        public class GameServices : IGameServices, IDisposable
        {
            private readonly UnitOfWork _unitOfWork;
    
            public GameServices(UnitOfWork unitOfWork)
            {
                _unitOfWork = unitOfWork;
            }
    
            public async Task<GameRequest> GetGameByIdAsync(int gameId)
            {
                var game = await _unitOfWork.GameRepository.GetByIdAsync(gameId);
    
                return game;
            }
    
            public async Task<IEnumerable<GameRequest>> GetAllGamesAsync()
            {
                var games = await _unitOfWork.GameRepository.GetAllAsync();
    
                return games;
            }
    
           
    
            public async Task<HttpResponseMessage> GamePurchase(RequestDto requestDto)
            {
                HttpResponseMessage response = null;
                using (_unitOfWork)
                {
                    response = await CallRazerService(requestDto);
                    return response;
                }
            }
    
            
    
            private async Task<HttpResponseMessage> CallRazerService(RequestDto requestDto)
            {
                HttpResponseMessage response = null;
    
                //some code here
                
    
                #region Call Razer initiate/confirm
    
                //Call Razer for initiation
                response = await Utilities.CallRazer(gameRequest, "purchaseinitiation");
    
                //Read response
                var htmlResponse = await response.Content.ReadAsStringAsync();
                var gameResponse = JsonConvert.DeserializeObject<GameResponse>(htmlResponse);
    
                
    			//some code there
    
                #endregion
    
                await _unitOfWork.SaveAsync();
    
                return response;
            }
    
            
    
            public void Dispose()
            {
                _unitOfWork.Dispose();
            }
        }
    }
    
    namespace BusinessService.Utility
    {
        public class Utilities
        {
            private static readonly HttpClient _httpClient = new HttpClient();
    
    
           //some code here
    
            public static async Task<HttpResponseMessage> CallRazer(GameRequest gameRequest, string url)
            {
               
                    FormUrlEncodedContent content = null;
                      try
                        {
                            //Convert request
                            var keyValues = gameRequest.ToKeyValue();
                            content = new FormUrlEncodedContent(keyValues);
    
                            //Call Game Sultan
                            var response = await _httpClient.PostAsync("https://test.com/" + url, content);
                            return response;
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e);
                            throw;
                        }
                        finally
                        {
                            content.Dispose();
                        }
                   
                
            }
    
            
        }
    
        public static class ObjectExtensions
        {
            public static IDictionary<string, string> ToKeyValue(this object metaToken)
            {
                if (metaToken == null)
                {
                    return null;
                }
    
                JToken token = metaToken as JToken;
                if (token == null)
                {
                    return ToKeyValue(JObject.FromObject(metaToken));
                }
    
                if (token.HasValues)
                {
                    var contentData = new Dictionary<string, string>();
                    
                    foreach (var child in token.Children().ToList())
                    {
                        var childContent = child.ToKeyValue();
                        if (childContent != null)
                        {
                            contentData = contentData.Concat(childContent)
                                .ToDictionary(k => k.Key, v => v.Value);
                        }
                    }
    
                    return contentData;
                }
    
                var jValue = token as JValue;
                if (jValue?.Value == null)
                {
                    return null;
                }
    
                var value = jValue?.Type == JTokenType.Date
                    ? jValue?.ToString("o", CultureInfo.InvariantCulture)
                    : jValue?.ToString(CultureInfo.InvariantCulture);
    
                return new Dictionary<string, string> {{token.Path, value}};
            }
        }
    }
    

    Monday, August 12, 2019 6:52 PM