public static ILogger CreateLogger(string serviceName)
{
if (string.IsNullOrEmpty(serviceName))
{
serviceName = nameof(serviceName);
}
var properties = new WebRequestProperties
{
Url = new Uri(BuildUri(serviceName)),
HttpMethod = DefaultHttpMethod,
UserAgent = GetOsVersion(),
MachineName = GetMachineName(),
RemoteAddress = GetLocalIpAddress(),
Request = new RequestProperties(),
Response = new ResponseProperties(),
StartDateTime = DateTime.UtcNow
};
Logger logger = new Logger();
logger.DataContainer.WebRequestProperties = properties;
return(logger);
}
private static void AddUserClaims(HttpRequest request, WebRequestProperties properties)
{
if (request.HttpContext.User?.Identity == null || request.HttpContext.User.Identity.IsAuthenticated == false)
{
return;
}
if ((request.HttpContext.User != null) == false)
{
return;
}
ClaimsPrincipal claimsPrincipal = (ClaimsPrincipal)request.HttpContext.User;
ClaimsIdentity identity = (ClaimsIdentity)claimsPrincipal?.Identity;
if (identity == null)
{
return;
}
List <KeyValuePair <string, string> > claims = ToDictionary(identity);
properties.Request.Claims = claims;
properties.IsAuthenticated = true;
UserDetails user = KissLogConfiguration.Options.ApplyGetUser(properties.Request);
properties.User = user;
}
public static void NotifyListeners(this ILogger logger)
{
if (logger == null)
{
return;
}
if (logger is Logger theLogger)
{
WebRequestProperties webRequestProperties = theLogger.DataContainer.WebRequestProperties;
if (webRequestProperties.Response == null)
{
webRequestProperties.Response = new ResponseProperties
{
HttpStatusCode = HttpStatusCode.OK
};
}
if (theLogger.DataContainer.Exceptions.Any())
{
webRequestProperties.Response.HttpStatusCode = HttpStatusCode.InternalServerError;
}
webRequestProperties.EndDateTime = DateTime.UtcNow;
}
Logger.NotifyListeners(logger);
}
private string Format(WebRequestProperties webRequestProperties)
{
if (webRequestProperties == null)
{
return(string.Empty);
}
return(_textFormatter.Format(webRequestProperties));
}
private void PostAuthenticateRquest(object sender, EventArgs e)
{
HttpContext ctx = HttpContext.Current;
WebRequestProperties properties = (WebRequestProperties)ctx.Items[Constants.HttpRequestPropertiesKey];
if (properties == null)
{
return;
}
if ((ctx.User is ClaimsPrincipal) == false)
{
return;
}
ClaimsPrincipal claimsPrincipal = (ClaimsPrincipal)ctx.User;
if (claimsPrincipal.Identity == null)
{
return;
}
if (claimsPrincipal.Identity.IsAuthenticated == false)
{
return;
}
properties.IsAuthenticated = true;
properties.User = new UserDetails
{
Name = claimsPrincipal.Identity.Name,
};
ClaimsIdentity claimsIdentity = claimsPrincipal?.Identity as ClaimsIdentity;
if (claimsIdentity == null)
{
return;
}
List <KeyValuePair <string, string> > claims = DataParser.ToDictionary(claimsIdentity);
properties.Request.Claims = claims;
UserDetails user = KissLogConfiguration.Options.ApplyGetUser(properties.Request);
if (user != null)
{
user.Name = user.Name ?? claimsIdentity.Name;
}
properties.User = user;
}
public static WebRequestProperties Create(HttpRequest request)
{
WebRequestProperties result = new WebRequestProperties();
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);
RequestProperties requestProperties = new RequestProperties();
result.Request = requestProperties;
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);
requestProperties.Headers = headers;
requestProperties.QueryString = queryString;
requestProperties.FormData = formData;
requestProperties.ServerVariables = serverVariables;
requestProperties.Cookies = cookies;
string inputStream = null;
if (InternalHelpers.ShouldLogInputStream(headers))
{
inputStream = ReadInputStream(request);
}
requestProperties.InputStream = inputStream;
return(result);
}
private static ArgsResult CreateArgs(Logger[] loggers)
{
Logger defaultLogger = loggers.FirstOrDefault(p => p.CategoryName == Logger.DefaultCategoryName) ?? loggers.First();
LoggerDataContainer dataContainer = defaultLogger.DataContainer;
WebRequestProperties webRequestProperties = dataContainer.WebRequestProperties;
string errorMessage = dataContainer.Exceptions.LastOrDefault()?.ExceptionMessage;
List <LogMessagesGroup> logMessages = new List <LogMessagesGroup>();
List <CapturedException> exceptions = new List <CapturedException>();
foreach (Logger logger in loggers)
{
logMessages.Add(new LogMessagesGroup
{
CategoryName = logger.CategoryName,
Messages = logger.DataContainer.LogMessages.ToList()
});
exceptions.AddRange(logger.DataContainer.Exceptions);
}
exceptions = exceptions.Distinct(new CapturedExceptionComparer()).ToList();
if (defaultLogger.IsCreatedByHttpRequest() == false && exceptions.Any())
{
webRequestProperties.Response.HttpStatusCode = System.Net.HttpStatusCode.InternalServerError;
}
List <LoggerFile> files = dataContainer.LoggerFiles.GetFiles().ToList();
FlushLogArgs args = new FlushLogArgs
{
IsCreatedByHttpRequest = defaultLogger.IsCreatedByHttpRequest(),
WebRequestProperties = webRequestProperties,
MessagesGroups = logMessages,
CapturedExceptions = exceptions
};
args.Files = files;
return(new ArgsResult
{
Args = args,
Files = files
});
}
private void Context_PostAcquireRequestState(object sender, EventArgs e)
{
HttpContext ctx = HttpContext.Current;
if (ctx.Session == null)
{
return;
}
// We need to add a dummy session value, otherwise ctx.Session.IsNewSession will always be true
ctx.Session.Add("X-KissLogSession", true);
WebRequestProperties requestProperties = (WebRequestProperties)ctx.Items[Constants.HttpRequestPropertiesKey];
if (requestProperties == null)
{
return;
}
requestProperties.IsNewSession = ctx.Session.IsNewSession;
requestProperties.SessionId = ctx.Session.SessionID;
}
public async Task Invoke(HttpContext context)
{
Logger logger = Logger.Factory.Get() as Logger;
if (logger == null)
{
return;
}
logger.DataContainer.AddProperty(InternalHelpers.IsCreatedByHttpRequest, true);
WebRequestProperties properties = WebRequestPropertiesFactory.Create(context.Request);
Exception ex = null;
Stream originalBodyStream = context.Response.Body;
TemporaryFile responseBodyFile = null;
long contentLength = 0;
try
{
using (var responseStream = new MemoryStream())
{
context.Response.Body = responseStream;
await _next(context);
responseBodyFile = new TemporaryFile();
await ReadResponse(context.Response, responseBodyFile.FileName);
contentLength = responseStream.Length;
if (CanWriteToResponseBody(context.Response))
{
await responseStream.CopyToAsync(originalBodyStream);
}
}
}
catch (Exception e)
{
ex = e;
throw;
}
finally
{
context.Response.Body = originalBodyStream;
properties.EndDateTime = DateTime.UtcNow;
HttpStatusCode statusCode = (HttpStatusCode)context.Response.StatusCode;
if (ex != null)
{
statusCode = HttpStatusCode.InternalServerError;
logger.Log(LogLevel.Error, ex);
}
if (logger.DataContainer.ExplicitHttpStatusCode.HasValue)
{
statusCode = logger.DataContainer.ExplicitHttpStatusCode.Value;
}
ResponseProperties response = ResponsePropertiesFactory.Create(context.Response);
response.HttpStatusCode = statusCode;
response.ContentLength = contentLength;
properties.Response = response;
if (responseBodyFile != null && InternalHelpers.PreFilterShouldLogResponseBody(logger, responseBodyFile, response))
{
string responseFileName = InternalHelpers.ResponseFileName(response.Headers);
logger.LogFile(responseBodyFile.FileName, responseFileName);
}
logger.DataContainer.WebRequestProperties = properties;
responseBodyFile?.Dispose();
IEnumerable <ILogger> loggers = Logger.Factory.GetAll();
Logger.NotifyListeners(loggers.ToArray());
}
}
public static WebRequestProperties Create(HttpRequest request)
{
WebRequestProperties result = new WebRequestProperties();
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();
RequestProperties requestProperties = new RequestProperties();
result.Request = requestProperties;
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();
requestProperties.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];
requestProperties.Cookies.Add(new KeyValuePair <string, string>(key, value));
}
foreach (string key in request.Query.Keys)
{
string value = string.Join("; ", request.Query[key]);
requestProperties.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]);
requestProperties.FormData.Add(new KeyValuePair <string, string>(key, value));
}
}
if (InternalHelpers.ShouldLogInputStream(requestProperties.Headers))
{
inputStream = ReadInputStream(request);
}
result.HttpReferer = httpReferer;
result.Request.InputStream = inputStream;
return(result);
}
public string Format(WebRequestProperties webRequestProperties)
{
return(_webRequestPropertiesTemplate(webRequestProperties));
}
private void EndRequest(object sender, EventArgs e)
{
HttpContext ctx = HttpContext.Current;
Logger logger = Logger.Factory.Get() as Logger;
if (logger == null)
{
return;
}
Exception ex = ctx.Server.GetLastError();
if (ex != null)
{
logger.Log(LogLevel.Error, ex);
}
var sniffer = ctx.Response.Filter as ResponseSniffer;
if (ctx.Response.StatusCode >= 400 && ex == null)
{
if (sniffer != null)
{
string responseContent = sniffer.GetContent();
if (string.IsNullOrEmpty(responseContent) == false)
{
logger.Log(LogLevel.Error, responseContent);
}
}
}
WebRequestProperties properties = (WebRequestProperties)HttpContext.Current.Items[Constants.HttpRequestPropertiesKey];
properties.EndDateTime = DateTime.UtcNow;
ResponseProperties response = WebResponsePropertiesFactory.Create(ctx.Response);
properties.Response = response;
if (logger.DataContainer.ExplicitHttpStatusCode.HasValue)
{
response.HttpStatusCode = logger.DataContainer.ExplicitHttpStatusCode.Value;
}
if (sniffer != null)
{
response.ContentLength = sniffer.MirrorStream.Length;
}
if (sniffer != null)
{
using (sniffer.MirrorStream)
{
sniffer.MirrorStream.Position = 0;
if (InternalHelpers.PreFilterShouldLogResponseBody(logger, sniffer.MirrorStream, response))
{
using (TemporaryFile tempFile = new TemporaryFile())
{
using (var fs = File.OpenWrite(tempFile.FileName))
{
sniffer.MirrorStream.CopyTo(fs);
}
string responseFileName = InternalHelpers.ResponseFileName(properties.Response.Headers);
logger.LogFile(tempFile.FileName, responseFileName);
}
}
}
}
logger.DataContainer.WebRequestProperties = properties;
IEnumerable <ILogger> loggers = Logger.Factory.GetAll();
Logger.NotifyListeners(loggers.ToArray());
}
