forked from ServiceStack/ServiceStack
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathRequestLogsService.cs
More file actions
131 lines (119 loc) · 6.2 KB
/
Copy pathRequestLogsService.cs
File metadata and controls
131 lines (119 loc) · 6.2 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using ServiceStack.DataAnnotations;
using ServiceStack.Host;
using ServiceStack.Text;
using ServiceStack.Web;
namespace ServiceStack.Admin
{
[Exclude(Feature.Soap)]
[DataContract]
public class RequestLogs
{
[DataMember(Order=1)] public int? BeforeSecs { get; set; }
[DataMember(Order=2)] public int? AfterSecs { get; set; }
[DataMember(Order=3)] public string IpAddress { get; set; }
[DataMember(Order=4)] public string ForwardedFor { get; set; }
[DataMember(Order=5)] public string UserAuthId { get; set; }
[DataMember(Order=6)] public string SessionId { get; set; }
[DataMember(Order=7)] public string Referer { get; set; }
[DataMember(Order=8)] public string PathInfo { get; set; }
[DataMember(Order=9)] public long[] Ids { get; set; }
[DataMember(Order=10)] public int? BeforeId { get; set; }
[DataMember(Order=11)] public int? AfterId { get; set; }
[DataMember(Order=12)] public bool? HasResponse { get; set; }
[DataMember(Order=13)] public bool? WithErrors { get; set; }
[DataMember(Order=14)] public int Skip { get; set; }
[DataMember(Order=15)] public int? Take { get; set; }
[DataMember(Order=16)] public bool? EnableSessionTracking { get; set; }
[DataMember(Order=17)] public bool? EnableResponseTracking { get; set; }
[DataMember(Order=18)] public bool? EnableErrorTracking { get; set; }
[DataMember(Order=19)] public TimeSpan? DurationLongerThan { get; set; }
[DataMember(Order=20)] public TimeSpan? DurationLessThan { get; set; }
}
[Exclude(Feature.Soap)]
[DataContract]
public class RequestLogsResponse
{
public RequestLogsResponse()
{
this.Results = new List<RequestLogEntry>();
}
[DataMember(Order=1)] public List<RequestLogEntry> Results { get; set; }
[DataMember(Order=2)] public Dictionary<string, string> Usage { get; set; }
[DataMember(Order=3)] public ResponseStatus ResponseStatus { get; set; }
}
[DefaultRequest(typeof(RequestLogs))]
public class RequestLogsService : Service
{
private static readonly Dictionary<string, string> Usage = new Dictionary<string, string> {
{"int BeforeSecs", "Requests before elapsed time"},
{"int AfterSecs", "Requests after elapsed time"},
{"string IpAddress", "Requests matching Ip Address"},
{"string ForwardedFor", "Requests matching Forwarded Ip Address"},
{"string UserAuthId", "Requests matching UserAuthId"},
{"string SessionId", "Requests matching SessionId"},
{"string Referer", "Requests matching Http Referer"},
{"string PathInfo", "Requests matching PathInfo"},
{"int BeforeId", "Requests before RequestLog Id"},
{"int AfterId", "Requests after RequestLog Id"},
{"bool WithErrors", "Requests with errors"},
{"int Skip", "Skip past N results"},
{"int Take", "Only look at last N results"},
{"bool EnableSessionTracking", "Turn On/Off Session Tracking"},
{"bool EnableResponseTracking", "Turn On/Off Tracking of Responses"},
{"bool EnableErrorTracking", "Turn On/Off Tracking of Errors"},
{"TimeSpan DurationLongerThan", "Requests with a duration longer than"},
{"TimeSpan DurationLessThan", "Requests with a duration less than"},
};
public IRequestLogger RequestLogger { get; set; }
public object Any(RequestLogs request)
{
if (RequestLogger == null)
throw new Exception("No IRequestLogger is registered");
if (!HostContext.DebugMode)
{
RequiredRoleAttribute.AssertRequiredRoles(Request, RequestLogger.RequiredRoles);
}
if (request.EnableSessionTracking.HasValue)
RequestLogger.EnableSessionTracking = request.EnableSessionTracking.Value;
var now = DateTime.UtcNow;
var logs = RequestLogger.GetLatestLogs(request.Take).AsQueryable();
if (request.BeforeSecs.HasValue)
logs = logs.Where(x => (now - x.DateTime) <= TimeSpan.FromSeconds(request.BeforeSecs.Value));
if (request.AfterSecs.HasValue)
logs = logs.Where(x => (now - x.DateTime) > TimeSpan.FromSeconds(request.AfterSecs.Value));
if (!request.IpAddress.IsNullOrEmpty())
logs = logs.Where(x => x.IpAddress == request.IpAddress);
if (!request.UserAuthId.IsNullOrEmpty())
logs = logs.Where(x => x.UserAuthId == request.UserAuthId);
if (!request.SessionId.IsNullOrEmpty())
logs = logs.Where(x => x.SessionId == request.SessionId);
if (!request.Referer.IsNullOrEmpty())
logs = logs.Where(x => x.Referer == request.Referer);
if (!request.PathInfo.IsNullOrEmpty())
logs = logs.Where(x => x.PathInfo == request.PathInfo);
if (!request.Ids.IsEmpty())
logs = logs.Where(x => request.Ids.Contains(x.Id));
if (request.BeforeId.HasValue)
logs = logs.Where(x => x.Id <= request.BeforeId);
if (request.AfterId.HasValue)
logs = logs.Where(x => x.Id > request.AfterId);
if (request.WithErrors.HasValue)
logs = request.WithErrors.Value
? logs.Where(x => x.ErrorResponse != null)
: logs.Where(x => x.ErrorResponse == null);
if (request.DurationLongerThan.HasValue)
logs = logs.Where(x => x.RequestDuration > request.DurationLongerThan.Value);
if (request.DurationLessThan.HasValue)
logs = logs.Where(x => x.RequestDuration < request.DurationLessThan.Value);
var results = logs.Skip(request.Skip).OrderByDescending(x => x.Id).ToList();
return new RequestLogsResponse {
Results = results,
Usage = Usage,
};
}
}
}