{{ message }}
forked from NpgsqlRest/NpgsqlRest
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathNpgsqlRestLogger.cs
More file actions
232 lines (179 loc) · 15.7 KB
/
Copy pathNpgsqlRestLogger.cs
File metadata and controls
232 lines (179 loc) · 15.7 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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
using Microsoft.AspNetCore.Routing;
using System.Xml.Linq;
using Npgsql;
namespace NpgsqlRest;
public static partial class Log
{
[LoggerMessage(Level = LogLevel.Error, Message = "Could not read a value from {commandText} mapped to {method} {path}")]
public static partial void CouldNotReadCommand(this ILogger logger, string commandText, string method, string path);
[LoggerMessage(Level = LogLevel.Warning, Message = "Could not parse JSON body {body}, skipping path {path}.")]
public static partial void CouldNotParseJson(this ILogger logger, string body, string path);
[LoggerMessage(Level = LogLevel.Warning, Message = "Could not parse JSON body {body}, skipping path {path}. Error: {error}")]
public static partial void CouldNotParseJson(this ILogger logger, string body, string path, string error);
[LoggerMessage(Level = LogLevel.Warning, Message = "Endpoint {method} {url} changed request parameter type from body to query string because body will be used for parameter named \"{bodyParameterName}\".")]
public static partial void EndpointTypeChanged(this ILogger logger, string method, string url, string bodyParameterName);
[LoggerMessage(Level = LogLevel.Information, Message = "Created endpoint {method} {url}")]
public static partial void EndpointCreated(this ILogger logger, string method, string url);
[LoggerMessage(Level = LogLevel.Warning, Message = "Invalid HTTP method '{method}' in comment for routine '{schema}.{name}'. Using default '{usingDefault}'")]
public static partial void InvalidHttpMethodComment(this ILogger logger, string method, string schema, string name, Method usingDefault);
[LoggerMessage(Level = LogLevel.Warning, Message = "Invalid URL path segment '{urlPathSegment}' in comment for routine '{schema}.{name}'. Using default '{defaultUrl}'")]
public static partial void InvalidUrlPathSegmentComment(this ILogger logger, string urlPathSegment, string schema, string name, string defaultUrl);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set HTTP by the comment annotation to {method} {url}")]
public static partial void CommentSetHttp(this ILogger logger, RoutineType type, string schema, string name, Method method, string url);
[LoggerMessage(Level = LogLevel.Warning, Message = "Invalid parameter type '{type}' in comment for routine '{schema}.{name}' Allowed values are QueryString or Query or BodyJson or Json. Using default '{defaultType}'")]
public static partial void InvalidParameterTypeComment(this ILogger logger, string type, string schema, string name, RequestParamType defaultType);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set REQUEST PARAMETER TYPE by the comment annotation to {requestParamType}")]
public static partial void CommentSetParameterType(this ILogger logger, RoutineType type, string schema, string name, RequestParamType requestParamType);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set REQUIRED AUTHORIZATION by the comment annotation.")]
public static partial void CommentSetAuth(this ILogger logger, RoutineType type, string schema, string name);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set REQUIRED AUTHORIZATION FOR ROLES {roles} by the comment annotation.")]
public static partial void CommentSetAuthRoles(this ILogger logger, RoutineType type, string schema, string name, HashSet<string> roles);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set ALLOW ANONYMOUS by the comment annotation.")]
public static partial void CommentSetAnon(this ILogger logger, RoutineType type, string schema, string name);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set COMMAND TIMEOUT by the comment annotation to {parsedTimeout} seconds")]
public static partial void CommentSetTimeout(this ILogger logger, RoutineType type, string schema, string name, string parsedTimeout);
[LoggerMessage(Level = LogLevel.Warning, Message = "Invalid command timeout '{timeout}' in comment for routine '{schema}.{name}'. Using default command timeout '{defaultTimeout}'")]
public static partial void InvalidTimeoutComment(this ILogger logger, string timeout, string schema, string name, int? defaultTimeout);
[LoggerMessage(Level = LogLevel.Warning, Message = "Invalid request headers mode '{mode}' in comment for routine '{schema}.{name}' Allowed values are Ignore or Context or Parameter. Using default '{defaultRequestHeadersMode}'")]
public static partial void InvalidRequestHeadersModeComment(this ILogger logger, string mode, string schema, string name, RequestHeadersMode defaultRequestHeadersMode);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set REQUEST HEADERS MODE by the comment annotation to \"{requestHeadersMode}\"")]
public static partial void CommentSetRequestHeadersMode(this ILogger logger, RoutineType type, string schema, string name, string requestHeadersMode);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set REQUEST HEADERS PARAMETER NAME by the comment annotation to \"{requestHeadersParamName}\"")]
public static partial void CommentSetRequestHeadersParamName(this ILogger logger, RoutineType type, string schema, string name, string requestHeadersParamName);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set BODY PARAMETER NAME by the comment annotation to \"{bodyParamName}\"")]
public static partial void CommentSetBodyParamName(this ILogger logger, RoutineType type, string schema, string name, string bodyParamName);
[LoggerMessage(Level = LogLevel.Warning, Message = "Invalid text response null handling mode '{mode}' in comment for routine '{schema}.{name}'. Allowed values are EmptyString or NullLiteral or NoContent. Using default '{textResponseNullHandling}'")]
public static partial void InvalidResponseNullHandlingModeComment(this ILogger logger, string mode, string schema, string name, TextResponseNullHandling textResponseNullHandling);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set TEXT RESPONSE NULL HANDLING by the comment annotation to \"{textResponseNullHandling}\"")]
public static partial void CommentSetTextResponseNullHandling(this ILogger logger, RoutineType type, string schema, string name, string textResponseNullHandling);
[LoggerMessage(Level = LogLevel.Warning, Message = "Invalid query string null handling mode '{mode}' in comment for routine '{schema}.{name}'. Allowed values are EmptyString or NullLiteral or Ignore. Using default '{queryStringNullHandling}'\"")]
public static partial void InvalidQueryStringNullHandlingComment(this ILogger logger, string mode, string schema, string name, QueryStringNullHandling queryStringNullHandling);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set QUERY STRING NULL HANDLING by the comment annotation to \"{queryStringNullHandling}\"")]
public static partial void CommentSetQueryStringNullHandling(this ILogger logger, RoutineType type, string schema, string name, QueryStringNullHandling queryStringNullHandling);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set Content-Type HEADER by the comment annotation to \"{headerValue}\"")]
public static partial void CommentSetContentType(this ILogger logger, RoutineType type, string schema, string name, string headerValue);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set {headerName} HEADER by the comment annotation to \"{headerValue}\"")]
public static partial void CommentSetHeader(this ILogger logger, RoutineType type, string schema, string name, string headerName, string headerValue);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set LOGIN RESPONSE by the comment annotation.")]
public static partial void CommentSetLogin(this ILogger logger, RoutineType type, string schema, string name);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set LOGOUT RESPONSE by the comment annotation.")]
public static partial void CommentSetLogout(this ILogger logger, RoutineType type, string schema, string name);
[LoggerMessage(Level = LogLevel.Error, Message = "{type} {schema}.{name} is designated as login routine and it returns a status field that is not either boolean or numeric.")]
public static partial void WrongStatusType(this ILogger logger, RoutineType type, string schema, string name);
[LoggerMessage(Level = LogLevel.Warning, Message = "Endpoints are using Login and the DefaultAuthenticationType is null. DefaultAuthenticationType was set to {name}")]
public static partial void SetDefaultAuthenticationType(this ILogger logger, string name);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set BUFFER ROWS by the comment annotation to {parsedBuffer}")]
public static partial void CommentBufferRows(this ILogger logger, RoutineType type, string schema, string name, string parsedBuffer);
[LoggerMessage(Level = LogLevel.Warning, Message = "Invalid buffer rows '{buffer}' in comment for routine '{schema}.{name}'. Using the default buffer rows '{defaultBufferRows}'")]
public static partial void InvalidBufferRows(this ILogger logger, string buffer, string schema, string name, ulong defaultBufferRows);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set RAW MODE by the comment annotation.")]
public static partial void CommentSetRawMode(this ILogger logger, RoutineType type, string schema, string name);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set SEPARATOR by the comment annotation to {value}.")]
public static partial void CommentSetRawValueSeparator(this ILogger logger, RoutineType type, string schema, string name, string value);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set NEW LINE by the comment annotation to {value}.")]
public static partial void CommentSetRawNewLineSeparator(this ILogger logger, RoutineType type, string schema, string name, string value);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set COLUMN NAMES by the comment annotation.")]
public static partial void CommentRawSetColumnNames(this ILogger logger, RoutineType type, string schema, string name);
[LoggerMessage(Level = LogLevel.Warning, Message = "{type} {schema}.{name} has set CACHED by the comment annotation, routine doesn't return a single value. Routine will NOT be cached. Only single values can be cached.")]
public static partial void CommentInvalidCache(this ILogger logger, RoutineType type, string schema, string name);
[LoggerMessage(Level = LogLevel.Warning, Message = "{type} {schema}.{name} has set CACHED PARAMETER NAME to {param} by the comment annotation, but that parameter doesn't exists on this routine either converted or original. This cache parameter will be ignored.")]
public static partial void CommentInvalidCacheParam(this ILogger logger, RoutineType type, string schema, string name, string param);
[LoggerMessage(Level = LogLevel.Information, Message = "{type} {schema}.{name} has set CACHED with parameters {cachedParams} by the comment annotation.")]
public static partial void CommentCached(this ILogger logger, RoutineType type, string schema, string name, IEnumerable<string> cachedParams);
}
public static class NpgsqlRestLogger
{
private const string Info = "INFO";
private const string Notice = "NOTICE";
private const string Log = "LOG";
private const string Warning = "WARNING";
private const string Debug = "DEBUG";
private const string Error = "ERROR";
private const string Panic = "PANIC";
private const string LogPattern = "{where} {message}";
internal static readonly LogDefineOptions LogDefineOptions = new() { SkipEnabledCheck = true };
private static readonly Action<ILogger, string?, string, Exception?> __LogInformationCallback =
LoggerMessage.Define<string?, string>(LogLevel.Information, 0, LogPattern, LogDefineOptions);
private static readonly Action<ILogger, string?, string, Exception?> __LogWarningCallback =
LoggerMessage.Define<string?, string>(LogLevel.Warning, 1, LogPattern, LogDefineOptions);
private static readonly Action<ILogger, string?, string, Exception?> __LogDebugCallback =
LoggerMessage.Define<string?, string>(LogLevel.Debug, 2, LogPattern, LogDefineOptions);
private static readonly Action<ILogger, string?, string, Exception?> __LogErrorCallback =
LoggerMessage.Define<string?, string>(LogLevel.Error, 3, LogPattern, LogDefineOptions);
private static readonly Action<ILogger, string?, string, Exception?> __LogTraceCallback =
LoggerMessage.Define<string?, string>(LogLevel.Trace, 4, LogPattern, LogDefineOptions);
private static void LogInformation(ILogger? logger, string? where, string message)
{
if (logger?.IsEnabled(LogLevel.Information) is true)
{
__LogInformationCallback(logger, where, message, null);
}
}
private static void LogWarning(ILogger? logger, string? where, string message)
{
if (logger?.IsEnabled(LogLevel.Warning) is true)
{
__LogWarningCallback(logger, where, message, null);
}
}
private static void LogDebug(ILogger? logger, string? where, string message)
{
if (logger?.IsEnabled(LogLevel.Debug) is true)
{
__LogDebugCallback(logger, where, message, null);
}
}
private static void LogError(ILogger? logger, string? where, string message)
{
if (logger?.IsEnabled(LogLevel.Error) is true)
{
__LogErrorCallback(logger, where, message, null);
}
}
private static void LogTrace(ILogger? logger, string? where, string message)
{
if (logger?.IsEnabled(LogLevel.Trace) is true)
{
__LogTraceCallback(logger, where, message, null);
}
}
public static void LogEndpoint(ILogger? logger, RoutineEndpoint endpoint, string parameters, string command)
{
if (logger?.IsEnabled(LogLevel.Information) is true && endpoint.LogCallback is not null)
{
endpoint.LogCallback(logger, parameters, command, null);
}
}
public static void LogConnectionNotice(ILogger? logger, NpgsqlNoticeEventArgs args)
{
if (logger is null)
{
return;
}
var severity = args.Notice.Severity;
var where = string.Concat(args.Notice.Where, " ", severity);
if (string.Equals(Info, severity, StringComparison.OrdinalIgnoreCase) ||
string.Equals(Log, severity, StringComparison.OrdinalIgnoreCase) ||
string.Equals(Notice, severity, StringComparison.OrdinalIgnoreCase))
{
LogInformation(logger, where, args.Notice.MessageText);
}
else if (string.Equals(Warning, severity, StringComparison.OrdinalIgnoreCase))
{
LogWarning(logger, where, args.Notice.MessageText);
}
else if (string.Equals(Debug, severity, StringComparison.OrdinalIgnoreCase))
{
LogDebug(logger, where, args.Notice.MessageText);
}
else if (string.Equals(Error, severity, StringComparison.OrdinalIgnoreCase) ||
string.Equals(Panic, severity, StringComparison.OrdinalIgnoreCase))
{
LogError(logger, where, args.Notice.MessageText);
}
else
{
LogTrace(logger, where, args.Notice.MessageText);
}
}
}
You can’t perform that action at this time.