public static KissLog.Web.HttpRequest Create(HttpRequest request)
        {
            KissLog.Web.HttpRequest result = new KissLog.Web.HttpRequest();

            if (request == null)
            {
                return(result);
            }

            result.StartDateTime = DateTime.UtcNow;
            result.UserAgent     = request.UserAgent;
            result.Url           = request.Url;
            result.HttpMethod    = request.HttpMethod;
            result.HttpReferer   = request.UrlReferrer?.AbsolutePath;
            result.RemoteAddress = request.UserHostAddress;
            result.MachineName   = GetMachineName(request);

            KissLog.Web.RequestProperties properties = new KissLog.Web.RequestProperties();
            result.Properties = properties;

            var headers = DataParser.ToDictionary(request.Unvalidated.Headers);

            headers = FilterHeaders(headers);

            var queryString     = DataParser.ToDictionary(request.Unvalidated.QueryString);
            var formData        = DataParser.ToDictionary(request.Unvalidated.Form);
            var serverVariables = DataParser.ToDictionary(request.ServerVariables);

            serverVariables = FilterServerVariables(serverVariables);

            var cookies = DataParser.ToDictionary(request.Unvalidated.Cookies);

            properties.Headers         = headers;
            properties.QueryString     = queryString;
            properties.FormData        = formData;
            properties.ServerVariables = serverVariables;
            properties.Cookies         = cookies;
            string inputStream = null;

            if (InternalHelpers.ShouldLogInputStream(headers))
            {
                inputStream = ReadInputStream(request);
            }

            properties.InputStream = inputStream;

            return(result);
        }
Beispiel #2
0
        public static KissLog.Web.HttpRequest Create(HttpRequest request)
        {
            KissLog.Web.HttpRequest result = new Web.HttpRequest();

            if (request == null)
            {
                return(result);
            }

            try
            {
                if (request.HttpContext.Session != null && request.HttpContext.Session.IsAvailable)
                {
                    bool isNewSession = false;

                    string lastSessionId = request.HttpContext.Session.GetString("X-KissLogSessionId");
                    if (string.IsNullOrEmpty(lastSessionId) || string.Compare(lastSessionId, request.HttpContext.Session.Id, StringComparison.OrdinalIgnoreCase) != 0)
                    {
                        isNewSession = true;
                        request.HttpContext.Session.SetString("X-KissLogSessionId", request.HttpContext.Session.Id);
                    }

                    result.IsNewSession = isNewSession;
                    result.SessionId    = request.HttpContext.Session.Id;
                }
            }
            catch
            {
                // ignored
            }

            result.StartDateTime = DateTime.UtcNow;
            result.UserAgent     = request.Headers[HeaderNames.UserAgent].ToString();

            string url = request.GetDisplayUrl();

            result.Url = new Uri(url);

            result.MachineName = GetMachineName();

            KissLog.Web.RequestProperties properties = new KissLog.Web.RequestProperties();
            result.Properties = properties;

            AddUserClaims(request, result);

            result.RemoteAddress = request.HttpContext.Connection?.RemoteIpAddress?.ToString();
            result.HttpMethod    = request.Method;

            string httpReferer        = null;
            string requestContentType = null;
            string inputStream        = null;

            foreach (string key in request.Headers.Keys)
            {
                if (string.Compare(key, "Cookie", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    continue;
                }

                StringValues values;
                request.Headers.TryGetValue(key, out values);

                string value = values.ToString();

                properties.Headers.Add(new KeyValuePair <string, string>(key, value));

                if (string.Compare(key, "Referer", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    httpReferer = value;
                }

                if (string.Compare(key, "Content-Type", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    requestContentType = value;
                }
            }

            foreach (string key in request.Cookies.Keys)
            {
                string value = request.Cookies[key];

                properties.Cookies.Add(new KeyValuePair <string, string>(key, value));
            }

            foreach (string key in request.Query.Keys)
            {
                string value = string.Join("; ", request.Query[key]);

                properties.QueryString.Add(
                    new KeyValuePair <string, string>(key, value)
                    );
            }

            if (request.HasFormContentType)
            {
                foreach (string key in request.Form.Keys)
                {
                    string value = string.Join("; ", request.Form[key]);
                    properties.FormData.Add(new KeyValuePair <string, string>(key, value));
                }
            }

            if (InternalHelpers.ShouldLogInputStream(properties.Headers))
            {
                inputStream = ReadInputStream(request);
            }

            result.HttpReferer            = httpReferer;
            result.Properties.InputStream = inputStream;

            return(result);
        }