Example #1
0
        public void LogRequest_writes_correctly_composed_log_entry_to_the_RelayRepository_when_OnPremiseTargetResult_is_null()
        {
            var            logRepositoryMock = new Mock <ILogRepository>();
            var            pathSplitterMock  = new Mock <IPathSplitter>();
            IRequestLogger sut           = new RequestLogger(logRepositoryMock.Object, pathSplitterMock.Object);
            var            clientRequest = new OnPremiseConnectorRequest
            {
                Body            = new byte[] { 0, 0, 0 },
                RequestStarted  = new DateTime(2014, 1, 1),
                RequestFinished = new DateTime(2014, 1, 2)
            };
            RequestLogEntry result = null;

            logRepositoryMock.Setup(r => r.LogRequest(It.IsAny <RequestLogEntry>())).Callback <RequestLogEntry>(r => result = r);
            pathSplitterMock.Setup(p => p.Split(It.IsAny <string>())).Returns(new PathInformation {
                OnPremiseTargetKey = "that", LocalUrl = "/file.html"
            });

            sut.LogRequest(clientRequest, null, HttpStatusCode.PaymentRequired, Guid.Parse("4bb4ff98-ba03-49ee-bd83-5a229f63fade"), "35eff886-2d7c-4265-a6a4-f3f471ab93e8", "gimme/that/file.html");

            logRepositoryMock.Verify(r => r.LogRequest(It.IsAny <RequestLogEntry>()));
            result.HttpStatusCode.Should().Be(HttpStatusCode.PaymentRequired);
            result.OriginId.Should().Be(Guid.Parse("35eff886-2d7c-4265-a6a4-f3f471ab93e8"));
            result.LocalUrl.Should().Be("/file.html");
            result.OnPremiseTargetKey.Should().Be("that");
            result.OnPremiseConnectorInDate.Should().Be(new DateTime(2014, 1, 1));
            result.OnPremiseConnectorOutDate.Should().Be(new DateTime(2014, 1, 2));
            result.OnPremiseTargetInDate.Should().Be(null);
            result.OnPremiseTargetOutDate.Should().Be(null);
            result.ContentBytesIn.Should().Be(3L);
            result.ContentBytesOut.Should().Be(0L);
            result.LinkId.Should().Be(Guid.Parse("4bb4ff98-ba03-49ee-bd83-5a229f63fade"));
        }
        public async Task InvokeAsync(HttpContext context)
        {
            var request = context.Request;

            request.EnableRewind();

            var logEntry = new RequestLogEntry
            {
                Url       = request.Path,
                Method    = request.Method,
                Timestamp = DateTime.UtcNow
            };

            // default values and do not dispose underlying stream
            using (var reader = new StreamReader(request.Body, Encoding.UTF8, true, 1024, true))
            {
                logEntry.Body = await reader.ReadToEndAsync();
            }

            request.Body.Position = 0;
            var timer = Stopwatch.StartNew();

            await next(context);

            logEntry.DurationMs = timer.ElapsedMilliseconds;
            logEntry.StatusCode = context.Response.StatusCode;

            logger.LogObject(LogLevel.Information, logEntry);
        }
Example #3
0
        public void LogRequest(RequestLogEntry requestLogEntry)
        {
            using (var context = new RelayContext())
            {
                var link = new DbLink
                {
                    Id = requestLogEntry.LinkId
                };

                context.Links.Attach(link);

                context.RequestLogEntries.Add(new DbRequestLogEntry
                {
                    Id                        = Guid.NewGuid(),
                    ContentBytesIn            = requestLogEntry.ContentBytesIn,
                    ContentBytesOut           = requestLogEntry.ContentBytesOut,
                    OnPremiseConnectorInDate  = requestLogEntry.OnPremiseConnectorInDate,
                    OnPremiseConnectorOutDate = requestLogEntry.OnPremiseConnectorOutDate,
                    HttpStatusCode            = requestLogEntry.HttpStatusCode,
                    OnPremiseTargetInDate     = requestLogEntry.OnPremiseTargetInDate,
                    OnPremiseTargetKey        = requestLogEntry.OnPremiseTargetKey,
                    OnPremiseTargetOutDate    = requestLogEntry.OnPremiseTargetOutDate,
                    LocalUrl                  = requestLogEntry.LocalUrl ?? "/",
                    OriginId                  = requestLogEntry.OriginId,
                    Link                      = link,
                    LinkId                    = requestLogEntry.LinkId,
                });

                context.SaveChanges();
            }
        }
        public static void Run(string queueItem,
                               DateTimeOffset expirationTime,
                               DateTimeOffset insertionTime,
                               DateTimeOffset nextVisibleTime,
                               string queueTrigger,
                               string id,
                               string popReceipt,
                               int dequeueCount,
                               ICollector <RequestLogEntry> requestLog,
                               TraceWriter log)
        {
            log.Info($"[id:{id},insertionTime:{insertionTime},expirationTime:{expirationTime},nextVisibleTime:{nextVisibleTime},popReceipt:{popReceipt},dequeueCount:{dequeueCount},queueItem:{queueItem}");

            (var isHttpQueueObject, var httpQueueObject) = DeserializeQueueObject(queueItem);

            if (isHttpQueueObject)
            {
                var requestLogEntry = new RequestLogEntry();
                requestLogEntry.HTTPQueueObject             = queueItem;
                requestLogEntry.PartitionKey                = "Version1Stage1";
                requestLogEntry.RowKey                      = id;
                requestLogEntry.QueueInsertion              = insertionTime.ToUniversalTime().UtcDateTime;
                requestLogEntry.RequestUrl                  = httpQueueObject.RequestUri.ToString();
                requestLogEntry.ResponseIsSuccessStatusCode = httpQueueObject.ResponseIsSuccessStatusCode;
                requestLogEntry.ResponseReasonPhrase        = httpQueueObject.ResponseReasonPhrase;
                requestLogEntry.ResponseStatusCode          = httpQueueObject.ResponseStatusCode.ToString();
                requestLog.Add(requestLogEntry);
            }
        }
        public void Log(IRequest request, object requestDto, object response, TimeSpan requestDuration)
        {
            var requestType = requestDto != null ? requestDto.GetType() : null;

            if (ExcludeRequestDtoTypes != null
                && requestType != null
                && ExcludeRequestDtoTypes.Contains(requestType))
                return;
                
            var entry = new RequestLogEntry {
                Id = Interlocked.Increment(ref requestId),
                DateTime = DateTime.UtcNow,
                RequestDuration = requestDuration,
            };

            if (request != null)
            {
                entry.HttpMethod = request.Verb;
                entry.AbsoluteUri = request.AbsoluteUri;
                entry.PathInfo = request.PathInfo;
                entry.IpAddress = request.UserHostAddress;
                entry.ForwardedFor = request.Headers[HttpHeaders.XForwardedFor];
                entry.Referer = request.Headers[HttpHeaders.Referer];
                entry.Headers = request.Headers.ToDictionary();
                entry.UserAuthId = request.GetItemOrCookie(HttpHeaders.XUserAuthId);
                entry.SessionId = request.GetSessionId();
                entry.Items = SerializableItems(request.Items);
                entry.Session = EnableSessionTracking ? request.GetSession() : null;
            }

            if (HideRequestBodyForRequestDtoTypes != null
                && requestType != null
                && !HideRequestBodyForRequestDtoTypes.Contains(requestType)) 
            {
                entry.RequestDto = requestDto;
                if (request != null)
                {
                    entry.FormData = request.FormData.ToDictionary();

                    if (EnableRequestBodyTracking)
                    {
                        entry.RequestBody = request.GetRawBody();
                    }
                }
            }
            if (!response.IsErrorResponse()) {
                if (EnableResponseTracking)
                    entry.ResponseDto = response;
            }
            else {
                if (EnableErrorTracking)
                    entry.ErrorResponse = ToSerializableErrorResponse(response);
            }

            logEntries.Enqueue(entry);

            RequestLogEntry dummy;
            if (logEntries.Count > capacity)
                logEntries.TryDequeue(out dummy);
        }
        public void Log(IRequestContext requestContext, object requestDto, object response)
        {
            var requestType = requestDto != null?requestDto.GetType() : null;

            if (ExcludeRequestDtoTypes != null &&
                requestType != null &&
                ExcludeRequestDtoTypes.Contains(requestType))
            {
                return;
            }

            var httpReq = requestContext.Get <IHttpRequest>();
            var entry   = new RequestLogEntry {
                Id           = Interlocked.Increment(ref requestId),
                DateTime     = DateTime.UtcNow,
                HttpMethod   = httpReq.HttpMethod,
                AbsoluteUri  = httpReq.AbsoluteUri,
                PathInfo     = httpReq.PathInfo,
                IpAddress    = requestContext.IpAddress,
                ForwardedFor = httpReq.Headers[HttpHeaders.XForwardedFor],
                Referer      = httpReq.Headers[HttpHeaders.Referer],
                Headers      = httpReq.Headers.ToDictionary(),
                UserAuthId   = httpReq.GetItemOrCookie(HttpHeaders.XUserAuthId),
                SessionId    = httpReq.GetSessionId(),
                Items        = httpReq.Items,
                Session      = EnableSessionTracking ? httpReq.GetSession() : null,
            };

            if (HideRequestBodyForRequestDtoTypes != null &&
                requestType != null &&
                !HideRequestBodyForRequestDtoTypes.Contains(requestType))
            {
                entry.RequestDto = requestDto;
                entry.FormData   = httpReq.FormData.ToDictionary();
            }
            if (response.IsErrorResponse())
            {
                if (EnableResponseTracking)
                {
                    entry.ResponseDto = response;
                }
            }
            else
            {
                if (EnableErrorTracking)
                {
                    entry.ErrorResponse = ToSerializableErrorResponse(response);
                }
            }

            logEntries.Enqueue(entry);

            RequestLogEntry dummy;

            if (logEntries.Count > capacity)
            {
                logEntries.TryDequeue(out dummy);
            }
        }
Example #7
0
        private void WriteToLog(RequestLogEntry entry)
        {
            Directory.CreateDirectory(GetLogDirPath(DateTime.Now));

            using (StreamWriter log = new StreamWriter(GetLogFilePath(DateTime.Now), true))
            {
                log.WriteLine(JsonConvert.SerializeObject(entry));
            }
        }
        protected RequestLogEntry CreateEntry(IRequest request, object requestDto, object response, TimeSpan requestDuration, Type requestType)
        {
            var entry = new RequestLogEntry
            {
                Id              = Interlocked.Increment(ref requestId),
                DateTime        = DateTime.UtcNow,
                RequestDuration = requestDuration,
            };

            if (request != null)
            {
                entry.HttpMethod   = request.Verb;
                entry.AbsoluteUri  = request.AbsoluteUri;
                entry.PathInfo     = request.PathInfo;
                entry.IpAddress    = request.UserHostAddress;
                entry.ForwardedFor = request.Headers[HttpHeaders.XForwardedFor];
                entry.Referer      = request.Headers[HttpHeaders.Referer];
                entry.Headers      = request.Headers.ToDictionary();
                entry.UserAuthId   = request.GetItemOrCookie(HttpHeaders.XUserAuthId);
                entry.SessionId    = request.GetSessionId();
                entry.Items        = SerializableItems(request.Items);
                entry.Session      = EnableSessionTracking ? request.GetSession() : null;
                new NameValueCollection().ToDictionary();
            }

            if (HideRequestBodyForRequestDtoTypes != null &&
                requestType != null &&
                !HideRequestBodyForRequestDtoTypes.Contains(requestType))
            {
                entry.RequestDto = requestDto;
                if (request != null)
                {
                    entry.FormData = request.FormData.ToDictionary();

                    if (EnableRequestBodyTracking)
                    {
                        entry.RequestBody = request.GetRawBody();
                    }
                }
            }
            if (!response.IsErrorResponse())
            {
                if (EnableResponseTracking)
                {
                    entry.ResponseDto = response;
                }
            }
            else
            {
                if (EnableErrorTracking)
                {
                    entry.ErrorResponse = ToSerializableErrorResponse(response);
                }
            }

            return(entry);
        }
        protected RequestLogEntry CreateEntry(IRequest request, object requestDto, object response, TimeSpan requestDuration, Type requestType)
        {
            var entry = new RequestLogEntry
            {
                Id = Interlocked.Increment(ref requestId),
                DateTime = DateTime.UtcNow,
                RequestDuration = requestDuration,
            };

            if (request != null)
            {
                entry.HttpMethod = request.Verb;
                entry.AbsoluteUri = request.AbsoluteUri;
                entry.PathInfo = request.PathInfo;
                entry.IpAddress = request.UserHostAddress;
                entry.ForwardedFor = request.Headers[HttpHeaders.XForwardedFor];
                entry.Referer = request.Headers[HttpHeaders.Referer];
                entry.Headers = request.Headers.ToDictionary();
                entry.UserAuthId = request.GetItemOrCookie(HttpHeaders.XUserAuthId);
                entry.SessionId = request.GetSessionId();
                entry.Items = SerializableItems(request.Items);
                entry.Session = EnableSessionTracking ? request.GetSession() : null;
                new NameValueCollection().ToDictionary();
            }

            if (HideRequestBodyForRequestDtoTypes != null
                && requestType != null
                && !HideRequestBodyForRequestDtoTypes.Contains(requestType))
            {
                entry.RequestDto = requestDto;
                if (request != null)
                {
                    entry.FormData = request.FormData.ToDictionary();

                    if (EnableRequestBodyTracking)
                    {
                        entry.RequestBody = request.GetRawBody();
                    }
                }
            }
            if (!response.IsErrorResponse())
            {
                if (EnableResponseTracking)
                    entry.ResponseDto = response;
            }
            else
            {
                if (EnableErrorTracking)
                    entry.ErrorResponse = ToSerializableErrorResponse(response);
            }

            return entry;
        }
Example #10
0
 public bool Equals(RequestLogEntry other)
 {
     if (ReferenceEquals(null, other))
     {
         return(false);
     }
     if (ReferenceEquals(this, other))
     {
         return(true);
     }
     return(Equals(other.Message, Message));
 }
Example #11
0
        private void WriteRequestLog(string stage, RequestContext requestContext)
        {
            RequestLogEntry logEntry = new RequestLogEntry(requestContext);

            string folder   = HttpContext.Current.Request.MapPath(this.LogsPath);
            string fileName = DateTime.Now.ToString("yyyy-MM-dd");

            using (StreamWriter outputFile = new StreamWriter(folder + @"\" + $"{fileName}.txt", true))
            {
                outputFile.WriteLine($"[{stage}]");
                outputFile.WriteLine($"{logEntry}");
            }
        }
Example #12
0
        protected RequestLogEntry CreateEntry(IRequest request, object requestDto, object response, TimeSpan requestDuration, Type requestType)
        {
            var entry = new RequestLogEntry
            {
                Id              = Interlocked.Increment(ref requestId),
                DateTime        = CurrentDateFn(),
                RequestDuration = requestDuration,
            };

            if (request != null)
            {
                entry.HttpMethod        = request.Verb;
                entry.AbsoluteUri       = request.AbsoluteUri;
                entry.PathInfo          = request.PathInfo;
                entry.IpAddress         = request.UserHostAddress;
                entry.ForwardedFor      = request.Headers[HttpHeaders.XForwardedFor];
                entry.Referer           = request.Headers[HttpHeaders.Referer];
                entry.Headers           = request.Headers.ToDictionary();
                entry.UserAuthId        = request.GetItemStringValue(HttpHeaders.XUserAuthId);
                entry.Items             = SerializableItems(request.Items);
                entry.Session           = EnableSessionTracking ? request.GetSession() : null;
                entry.StatusCode        = request.Response.StatusCode;
                entry.StatusDescription = request.Response.StatusDescription;

                var isClosed = request.Response.IsClosed;
                if (!isClosed)
                {
                    entry.UserAuthId = request.GetItemOrCookie(HttpHeaders.XUserAuthId);
                    entry.SessionId  = request.GetSessionId();
                }

                if (HideRequestBodyForRequestDtoTypes != null &&
                    requestType != null &&
                    !HideRequestBodyForRequestDtoTypes.Contains(requestType))
                {
                    entry.RequestDto = requestDto;

                    if (!isClosed)
                    {
                        entry.FormData = request.FormData.ToDictionary();
                    }

                    if (EnableRequestBodyTracking)
                    {
#if NETSTANDARD2_0
                        // https://forums.servicestack.net/t/unexpected-end-of-stream-when-uploading-to-aspnet-core/6478/6
                        if (!request.ContentType.MatchesContentType(MimeTypes.MultiPartFormData))
                        {
                            entry.RequestBody = request.GetRawBody();
                        }
#else
                        entry.RequestBody = request.GetRawBody();
#endif
                    }
                }
            }

            if (!response.IsErrorResponse())
            {
                if (EnableResponseTracking)
                {
                    entry.ResponseDto = response.GetResponseDto();
                }
            }
            else
            {
                if (EnableErrorTracking)
                {
                    entry.ErrorResponse = ToSerializableErrorResponse(response);

                    if (response is IHttpError httpError)
                    {
                        entry.StatusCode        = (int)httpError.StatusCode;
                        entry.StatusDescription = httpError.StatusDescription;
                    }

                    if (response is Exception exception)
                    {
                        if (exception.InnerException != null)
                        {
                            exception = exception.InnerException;
                        }

                        entry.ExceptionSource = exception.Source;
                        entry.ExceptionData   = exception.Data;
                    }
                }
            }

            return(entry);
        }
Example #13
0
        protected RequestLogEntry CreateEntry(IRequest request, object requestDto, object response, TimeSpan requestDuration, Type requestType)
        {
            var entry = new RequestLogEntry
            {
                Id              = Interlocked.Increment(ref requestId),
                DateTime        = DateTime.UtcNow,
                RequestDuration = requestDuration,
            };

            if (request != null)
            {
                entry.HttpMethod        = request.Verb;
                entry.AbsoluteUri       = request.AbsoluteUri;
                entry.PathInfo          = request.PathInfo;
                entry.IpAddress         = request.UserHostAddress;
                entry.ForwardedFor      = request.Headers[HttpHeaders.XForwardedFor];
                entry.Referer           = request.Headers[HttpHeaders.Referer];
                entry.Headers           = request.Headers.ToDictionary();
                entry.UserAuthId        = request.GetItemStringValue(HttpHeaders.XUserAuthId);
                entry.Items             = SerializableItems(request.Items);
                entry.Session           = EnableSessionTracking ? request.GetSession() : null;
                entry.StatusCode        = request.Response.StatusCode;
                entry.StatusDescription = request.Response.StatusDescription;

                var isClosed = request.Response.IsClosed;
                if (!isClosed)
                {
                    entry.UserAuthId = request.GetItemOrCookie(HttpHeaders.XUserAuthId);
                    entry.SessionId  = request.GetSessionId();
                }

                if (HideRequestBodyForRequestDtoTypes != null &&
                    requestType != null &&
                    !HideRequestBodyForRequestDtoTypes.Contains(requestType))
                {
                    entry.RequestDto = requestDto;

                    if (!isClosed)
                    {
                        entry.FormData = request.FormData.ToDictionary();
                    }

                    if (EnableRequestBodyTracking)
                    {
                        entry.RequestBody = request.GetRawBody();
                    }
                }
            }

            if (!response.IsErrorResponse())
            {
                if (EnableResponseTracking)
                {
                    entry.ResponseDto = response.GetResponseDto();
                }
            }
            else
            {
                if (EnableErrorTracking)
                {
                    entry.ErrorResponse = ToSerializableErrorResponse(response);

                    var httpError = response as IHttpError;
                    if (httpError != null)
                    {
                        entry.StatusCode        = (int)httpError.StatusCode;
                        entry.StatusDescription = httpError.StatusDescription;
                    }

                    var exception = response as Exception;
                    if (exception != null)
                    {
                        if (exception.InnerException != null)
                        {
                            exception = exception.InnerException;
                        }

                        entry.ExceptionSource = exception.Source;
                        entry.ExceptionData   = exception.Data;
                    }
                }
            }

            return(entry);
        }
Example #14
0
 public bool Equals(RequestLogEntry other)
 {
     if (ReferenceEquals(null, other)) return false;
     if (ReferenceEquals(this, other)) return true;
     return Equals(other.Message, Message);
 }
 public void Insert(RequestLogEntry entry)
 {
     _context.RequestLogEntries.Add(entry);
     _context.SaveChanges();
 }
        public void Log(IRequest request, object requestDto, object response, TimeSpan requestDuration)
        {
            var requestType = requestDto != null?requestDto.GetType() : null;

            if (ExcludeRequestDtoTypes != null &&
                requestType != null &&
                ExcludeRequestDtoTypes.Contains(requestType))
            {
                return;
            }

            var entry = new RequestLogEntry {
                Id              = Interlocked.Increment(ref requestId),
                DateTime        = DateTime.UtcNow,
                RequestDuration = requestDuration,
            };

            if (request != null)
            {
                entry.HttpMethod   = request.Verb;
                entry.AbsoluteUri  = request.AbsoluteUri;
                entry.PathInfo     = request.PathInfo;
                entry.IpAddress    = request.UserHostAddress;
                entry.ForwardedFor = request.Headers[HttpHeaders.XForwardedFor];
                entry.Referer      = request.Headers[HttpHeaders.Referer];
                entry.Headers      = request.Headers.ToDictionary();
                entry.UserAuthId   = request.GetItemOrCookie(HttpHeaders.XUserAuthId);
                entry.SessionId    = request.GetSessionId();
                entry.Items        = SerializableItems(request.Items);
                entry.Session      = EnableSessionTracking ? request.GetSession() : null;
            }

            if (HideRequestBodyForRequestDtoTypes != null &&
                requestType != null &&
                !HideRequestBodyForRequestDtoTypes.Contains(requestType))
            {
                entry.RequestDto = requestDto;
                if (request != null)
                {
                    entry.FormData = request.FormData.ToDictionary();

                    if (EnableRequestBodyTracking)
                    {
                        entry.RequestBody = request.GetRawBody();
                    }
                }
            }
            if (!response.IsErrorResponse())
            {
                if (EnableResponseTracking)
                {
                    entry.ResponseDto = response;
                }
            }
            else
            {
                if (EnableErrorTracking)
                {
                    entry.ErrorResponse = ToSerializableErrorResponse(response);
                }
            }

            logEntries.Enqueue(entry);

            RequestLogEntry dummy;

            if (logEntries.Count > capacity)
            {
                logEntries.TryDequeue(out dummy);
            }
        }