public async Task GetEventsAsync(int page, DateTime?startingTs, LogQueryFilter queryFilter)
{
var events = await _repository.GetEventsPageAsync(page == 0? 1 : page, startingTs, queryFilter);
_context.Response.ContentType = "application/json";
await _context.Response.WriteAsync(JsonSerializer.Serialize(events, ApplicationBuilderExtensions._camelCaseJson));
}
public async Task GetEventsAsync(int page, DateTime?startingTs, LogQueryFilter queryFilter)
{
var events = await _repository.GetEventsPageAsync(page == 0? 1 : page, startingTs, queryFilter);
_context.Response.ContentType = "application/json";
await _context.Response.WriteAsync(JsonConvert.SerializeObject(events, _camelCaseSerializerSetting));
}
/// <summary>
/// Xem danh sách log theo filter: level, message,..
/// Phân trang
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public async Task <PaginatedList <LogModel> > GetLogByFilterAsync(LogQueryFilter filter)
{
var dataResponse = (await _elasticClient.SearchAsync <LogModel>(s => s.MatchAll()))
.Hits.Select(x => new LogModel
{
Id = x.Id,
Level = x.Source.Level,
Message = x.Source.Message
}).ToList();
if (!string.IsNullOrEmpty(filter.Level))
{
dataResponse = dataResponse.Where(x => x.Level.Equals(filter.Level)).ToList();
}
if (!string.IsNullOrEmpty(filter.Message))
{
dataResponse = dataResponse.Where(x => x.Message.Contains(filter.Message)).ToList();
}
if (!filter.PageSize.HasValue && !filter.PageNumber.HasValue)
{
return(await PaginatedList <LogModel> .CreateAsync(dataResponse));
}
return(await PaginatedList <LogModel> .CreateAsync(dataResponse, filter.PageNumber.Value, filter.PageSize.Value));
}
public QueryResult QuerySOLog(LogQueryFilter request)
{
int totalCount;
var dataTable = ObjectFactory <ILogQueryDA> .Instance.QuerySOLog(request, out totalCount);
return(new QueryResult()
{
Data = dataTable,
TotalCount = totalCount
});
}
public async Task GetEventsAsync(int page, DateTime?startingTs, LogQueryFilter queryFilter)
{
try
{
var events = await _repository.GetEventsPageAsync(page == 0? 1 : page, startingTs, queryFilter);
_context.Response.ContentType = "application/json";
await _context.Response.WriteAsync(JsonSerializer.Serialize(events, ApplicationBuilderExtensions._camelCaseJson));
}
catch (QueryEngineException ex)
{
_context.Response.ContentType = "application/json";
_context.Response.StatusCode = StatusCodes.Status400BadRequest;
await _context.Response.WriteAsync(JsonSerializer.Serialize(new { error = ex.Message }, ApplicationBuilderExtensions._camelCaseJson));
}
}
public async Task GetEventsAsync_passes_query_filter_to_repository()
{
// Arrange
var qf = new LogQueryFilter
{
QueryText = "p=v",
DateFilter = "5m",
DateRangeFilter = new List <DateTime>()
{
DateTime.Now, DateTime.Now
}
};
var repositoryMoq = new Mock <ISejilRepository>();
var controller = CreateController(CreateContextMoq().contextMoq.Object, repositoryMoq.Object, Mock.Of <ISejilSettings>());
// Act
await controller.GetEventsAsync(1, null, qf);
// Assert
repositoryMoq.Verify(p => p.GetEventsPageAsync(1, null, It.Is <LogQueryFilter>(f => f == qf)), Times.Once);
}
private static string BuildDateFilter(LogQueryFilter queryFilter)
{
if (queryFilter.DateFilter != null)
{
switch (queryFilter.DateFilter)
{
case "5m":
return("timestamp >= datetime('now', '-5 Minute')");
case "15m":
return("timestamp >= datetime('now', '-15 Minute')");
case "1h":
return("timestamp >= datetime('now', '-1 Hour')");
case "6h":
return("timestamp >= datetime('now', '-6 Hour')");
case "12h":
return("timestamp >= datetime('now', '-12 Hour')");
case "24h":
return("timestamp >= datetime('now', '-24 Hour')");
case "2d":
return("timestamp >= datetime('now', '-2 Day')");
case "5d":
return("timestamp >= datetime('now', '-5 Day')");
}
}
else if (queryFilter.DateRangeFilter != null)
{
return($"timestamp >= '{queryFilter.DateRangeFilter[0].ToString("yyyy-MM-dd")}' and timestamp < '{queryFilter.DateRangeFilter[1].ToString("yyyy-MM-dd")}'");
}
return("");
}
public string GetPagedLogEntriesSql(int page, int pageSize, DateTime?startingTimestamp, LogQueryFilter queryFilter)
{
if (page <= 0)
{
throw new ArgumentOutOfRangeException(nameof(page), "Argument must be greater than zero.");
}
if (pageSize <= 0)
{
throw new ArgumentOutOfRangeException(nameof(pageSize), "Argument must be greater than zero.");
}
var timestampWhereClause = TimestampWhereClause();
var queryWhereClause = QueryWhereClause();
return
($@"SELECT l.*, p.* from
(
SELECT * FROM log
{timestampWhereClause}
{queryWhereClause}{FiltersWhereClause()}
ORDER BY timestamp DESC
LIMIT {pageSize} OFFSET {(page - 1) * pageSize}
) l
LEFT JOIN log_property p ON l.id = p.logId
ORDER BY l.timestamp DESC, p.name");
string TimestampWhereClause()
{
var hasStartingTimestampConstraint = startingTimestamp.HasValue;
var hasDateFilter = queryFilter?.DateFilter != null || queryFilter?.DateRangeFilter != null;
var sql = new StringBuilder();
if (hasStartingTimestampConstraint || hasDateFilter)
{
sql.Append("WHERE (");
}
if (hasStartingTimestampConstraint)
{
sql.Append($@"timestamp <= '{startingTimestamp.Value.ToString("yyyy-MM-dd HH:mm:ss.fff")}'");
}
if (hasStartingTimestampConstraint && hasDateFilter)
{
sql.Append(" AND ");
}
if (hasDateFilter)
{
sql.Append(BuildDateFilter(queryFilter));
}
if (hasStartingTimestampConstraint || hasDateFilter)
{
sql.Append(")");
}
return(sql.ToString());
}
string QueryWhereClause() =>
String.IsNullOrWhiteSpace(queryFilter?.QueryText)
? ""
: timestampWhereClause.Length > 0
? $"AND ({BuildPredicate(queryFilter.QueryText, _nonPropertyColumns)})"
: $"WHERE ({BuildPredicate(queryFilter.QueryText, _nonPropertyColumns)})";
string FiltersWhereClause() =>
String.IsNullOrWhiteSpace(queryFilter?.LevelFilter) && (!queryFilter?.ExceptionsOnly ?? true)
? ""
: timestampWhereClause.Length > 0 || queryWhereClause.Length > 0
? $" AND ({BuildFilterWhereClause(queryFilter.LevelFilter, queryFilter.ExceptionsOnly)})"
: $"WHERE ({BuildFilterWhereClause(queryFilter.LevelFilter, queryFilter.ExceptionsOnly)})";
}
public async Task <IEnumerable <LogEntry> > GetEventsPageAsync(int page, DateTime?startingTimestamp, LogQueryFilter queryFilter, int?pageSize)
{
var sql = _sql.GetPagedLogEntriesSql(page, pageSize ?? _pageSize, startingTimestamp, queryFilter);
using (var conn = new SqlConnection(_connectionString))
{
await conn.OpenAsync();
var lookup = new Dictionary <long, LogEntry>();
var data = conn.Query <LogEntry, LogEntryProperty, LogEntry>(sql, (l, p) =>
{
LogEntry logEntry;
if (!lookup.TryGetValue(l.Id, out logEntry))
{
l.Level = Enum.Parse(typeof(LogEventLevel), l.Level).ToString();
lookup.Add(l.Id, logEntry = l);
}
if (p != null)
{
p.LogId = l.Id;
logEntry.Properties.Add(p);
}
return(logEntry);
}, splitOn: "Id, timestamp");
return(lookup.Values.AsEnumerable());
}
}
public async Task <IEnumerable <LogEntry> > GetEventsPageAsync(int page, DateTime?startingTimestamp, LogQueryFilter queryFilter)
{
var sql = _sql.GetPagedLogEntriesSql(page, _pageSize, startingTimestamp, queryFilter);
using (var conn = new SqliteConnection(_connectionString))
{
await conn.OpenAsync();
var lookup = new Dictionary <string, LogEntry>();
var data = conn.Query <LogEntry, LogEntryProperty, LogEntry>(sql, (l, p) =>
{
LogEntry logEntry;
if (!lookup.TryGetValue(l.Id, out logEntry))
{
lookup.Add(l.Id, logEntry = l);
}
if (p != null)
{
logEntry.Properties.Add(p);
}
return(logEntry);
}).ToList();
return(lookup.Values.AsEnumerable());
}
}
public async Task HttpPost_events_url_calls_controller_GetEventsAsync_method(string queryString,
string bodyContent, int expectedPageArg, DateTime?expectedstartingTsArg, LogQueryFilter expectedQueryFilterArg)
{
// Arrange
var url = "/sejil";
var target = $"{url}/events{queryString}";
var controllerMoq = new Mock <ISejilController>();
var server = CreateServer(url, controllerMoq.Object);
var content = bodyContent == null
? null
: new StringContent(bodyContent);
// Act
await server.CreateClient().PostAsync(target, content);
// Assert
controllerMoq.Verify(p => p.GetEventsAsync(
expectedPageArg, expectedstartingTsArg, It.Is <LogQueryFilter>(qf =>
qf.QueryText == expectedQueryFilterArg.QueryText &&
qf.DateFilter == expectedQueryFilterArg.DateFilter &&
Join(qf.DateRangeFilter) == Join(expectedQueryFilterArg.DateRangeFilter))), Times.Once);
}
