diff --git a/pom.xml b/pom.xml index 74a45d4d..f3876c4e 100644 --- a/pom.xml +++ b/pom.xml @@ -60,12 +60,12 @@ io.github.oneteme.traceapi traceapi-core - 0.0.12 + 0.0.15-SNAPSHOT io.github.oneteme jquery - 1.0.1-SNAPSHOT + 3.0.0 org.springframework.boot diff --git a/src/main/java/org/usf/trace/api/server/ApiController.java b/src/main/java/org/usf/trace/api/server/ApiController.java index 7885c2fa..7ad8dc75 100644 --- a/src/main/java/org/usf/trace/api/server/ApiController.java +++ b/src/main/java/org/usf/trace/api/server/ApiController.java @@ -8,6 +8,7 @@ import static org.usf.traceapi.core.RemoteTraceSender.MAIN_ENDPOINT; import static org.usf.traceapi.core.RemoteTraceSender.TRACE_ENDPOINT; +import java.time.Instant; import java.util.List; import javax.servlet.http.HttpServletRequest; @@ -33,7 +34,7 @@ @RestController @RequestMapping(value = TRACE_ENDPOINT, produces = APPLICATION_JSON_VALUE) @RequiredArgsConstructor -public class ApiController { +public class ApiController { private final RequestDao dao; private final SessionQueueService queueService; @@ -60,10 +61,17 @@ private ResponseEntity appendRequest(Session session){ } @GetMapping(INCOMING_ENDPOINT) - public List getIncomingRequestByIds( + public List getIncomingRequestByCriteria( @RequestParam(defaultValue = "true", name = "lazy") boolean lazy, - @RequestParam(required = false, name = "id") String[] id) { // without tree - return dao.getIncomingRequestById(lazy, id); + @RequestParam(required = false, name = "id") String[] id, + @RequestParam(required = false, name = "name") String[] name, + @RequestParam(required = false, name = "env") String[] env, + @RequestParam(required = false, name = "port") String[] port, + @RequestParam(required = false, name = "start") Instant start, + @RequestParam(required = false, name = "end") Instant end ){ // without tree + FilterCriteria fc = new FilterCriteria(id,null,name,env,port,null,start,end); + System.out.println(fc.toString()); + return dao.getIncomingRequestByCriteria(lazy,fc); } @GetMapping("incoming/request/{id}") @@ -72,10 +80,16 @@ public IncomingRequest getIncomingRequestById(@PathVariable String id) { // with } @GetMapping(MAIN_ENDPOINT) - public List getMainRequestByIds( + public List getMainRequestByCriteria( @RequestParam(defaultValue = "true", name = "lazy") boolean lazy, - @RequestParam(required = false, name = "id") String[] id) { // without tree - return dao.getMainRequestById(lazy, id); + @RequestParam(required = false, name = "id") String[] id, + @RequestParam(required = false, name = "env") String[] env, + @RequestParam(required = false, name = "launchmode") String[] launchMode, + @RequestParam(required = false, name = "start") Instant start, + @RequestParam(required = false, name = "end") Instant end ) { + + FilterCriteria fc = new FilterCriteria(null,id,null,env,null,launchMode,start,end); + return dao.getMainRequestByCriteria(lazy,fc); } @GetMapping("main/request/{id}") diff --git a/src/main/java/org/usf/trace/api/server/CommonRequestQueryResolver.java b/src/main/java/org/usf/trace/api/server/CommonRequestQueryResolver.java index 00b8ab56..9c38c007 100644 --- a/src/main/java/org/usf/trace/api/server/CommonRequestQueryResolver.java +++ b/src/main/java/org/usf/trace/api/server/CommonRequestQueryResolver.java @@ -6,6 +6,7 @@ import org.springframework.web.method.support.HandlerMethodArgumentResolver; import org.springframework.web.method.support.ModelAndViewContainer; import org.usf.jquery.core.RequestQuery; +import org.usf.jquery.core.RequestQueryBuilder; import org.usf.jquery.web.RequestQueryParam; import org.usf.jquery.web.RequestQueryParamResolver; @@ -15,7 +16,7 @@ public class CommonRequestQueryResolver implements HandlerMethodArgumentResolver @Override public boolean supportsParameter(MethodParameter parameter) { - return RequestQuery.class.isAssignableFrom(parameter.getNestedParameterType()) + return RequestQueryBuilder.class.isAssignableFrom(parameter.getNestedParameterType()) && parameter.hasParameterAnnotation(RequestQueryParam.class); } diff --git a/src/main/java/org/usf/trace/api/server/FilterCriteria.java b/src/main/java/org/usf/trace/api/server/FilterCriteria.java new file mode 100644 index 00000000..fcb53de8 --- /dev/null +++ b/src/main/java/org/usf/trace/api/server/FilterCriteria.java @@ -0,0 +1,114 @@ +package org.usf.trace.api.server; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.Setter; + +import java.sql.Time; +import java.sql.Timestamp; +import java.time.Instant; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Objects; +import java.util.stream.Stream; + +import static java.sql.Types.TIMESTAMP; +import static java.sql.Types.VARCHAR; + +@Getter +@Setter +@AllArgsConstructor +public class FilterCriteria { + + private final String[] idIncoming; // + + private final String[] idMain; + private final String[] name; + private final String[] env; + private final String[] port; + + private final String[] launchMode; + private final Instant start; + private final Instant end; + + + public String toSql(Filters idIncomingColname, + Filters idMainColname, + Filters nameColname, + Filters envColname, + Filters portColname, + Filters launchModeColName, + Filters startColName, + Filters endColName, + Collection args, + Collection argTypes) { + + var sql = " WHERE 1 = 1"; + sql += toSql(idIncomingColname,args,argTypes,getIdIncoming()); + sql += toSql(idMainColname,args,argTypes,getIdMain()); + sql += toSql(nameColname,args,argTypes,getName()); + sql += toSql(envColname,args,argTypes,getEnv()); + sql += toSql(portColname,args,argTypes,getPort()); + sql += toSql(launchModeColName,args,argTypes,getLaunchMode()); + sql += startToSql(startColName,args,argTypes,getStart()) ; + sql += endToSql( endColName,args,argTypes,getEnd()); + return sql; + } + + + String toSql(Filters colname, Collection args, Collection argTypes, String... values){ + if(values == null || values.length == 0){ + return ""; + } + + String sql = ""; + if(Stream.of(values).anyMatch(Objects::isNull)){ + sql = colname + " IS NULL"; + } + if(!sql.isEmpty()){ + if(values.length == 1){ + return " AND "+ sql; + } + return " AND (" + sql + " " + colname + "IN(" + Utils.nArg(values.length) + "))";//error + } + args.addAll(Arrays.asList(values)); + argTypes.addAll(Collections.nCopies(values.length, colname.getType())); + return " AND "+ colname + " IN(" + Utils.nArg(values.length) + ")"; + } + + String startToSql(Filters start , Collection args, Collection argTypes, Instant value){ + + if(value != null ){ + args.add(Timestamp.from(value)); + argTypes.add(TIMESTAMP); + return " AND "+ start +" >= ?"; + } + return ""; + } + + String endToSql(Filters end , Collection args, Collection argTypes, Instant value){ + + if(value != null ){ + args.add(Timestamp.from(value)); + argTypes.add(TIMESTAMP); + return " AND "+ end +" < ?"; + } + return ""; + } + + + @Override + public String toString() { + return "FilterCriteria{" + + "id=" + Arrays.toString(idIncoming) + + ", host=" + Arrays.toString(name) + + ", env=" + Arrays.toString(env) + + ", port=" + Arrays.toString(port) + + ", start='" + start + '\'' + + ", end='" + end + '\'' + + '}'; + } + + +} diff --git a/src/main/java/org/usf/trace/api/server/Filters.java b/src/main/java/org/usf/trace/api/server/Filters.java new file mode 100644 index 00000000..77fc6c11 --- /dev/null +++ b/src/main/java/org/usf/trace/api/server/Filters.java @@ -0,0 +1,27 @@ +package org.usf.trace.api.server; + +import static java.sql.Types.*; + + + +public enum Filters { + ID_IN_REQ(VARCHAR), + ID_MAIN_REQ(VARCHAR), + VA_APP_NME(VARCHAR), + VA_ENV(VARCHAR), + CD_PRT(INTEGER), + DH_DBT(TIMESTAMP), + DH_FIN(TIMESTAMP), + LNCH(VARCHAR); + private int columnType; + + Filters(int columnType) { + this.columnType = columnType; + } + + + + public int getType() { + return this.columnType; + } +} diff --git a/src/main/java/org/usf/trace/api/server/MetadataController.java b/src/main/java/org/usf/trace/api/server/MetadataController.java index 9bdc46fa..eb358560 100644 --- a/src/main/java/org/usf/trace/api/server/MetadataController.java +++ b/src/main/java/org/usf/trace/api/server/MetadataController.java @@ -3,7 +3,7 @@ import static java.util.Arrays.asList; import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE; import static org.usf.trace.api.server.config.TraceApiColumn.*; -import static org.usf.trace.api.server.config.TraceApiTable.INCOMING_REQUEST_TABLE; +import static org.usf.trace.api.server.config.TraceApiTable.REQUEST; import java.util.List; @@ -26,27 +26,27 @@ public class MetadataController { @GetMapping("aggregate") List fetch() { return asList( - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, COUNT, COUNT.reference(), "Nombre d'appels", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, ELAPSEDTIME, ELAPSEDTIME.reference(), "temps de réponse (s)", "s"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, AVG_ELAPSEDTIME, AVG_ELAPSEDTIME.reference(), "temps de réponse moyen(s)", "s"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, MAX_ELAPSEDTIME, MAX_ELAPSEDTIME.reference(), "temps de réponse max(s)", "s"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, MIN_ELAPSEDTIME, MIN_ELAPSEDTIME.reference(), "temps de réponse min(s)", "s"), + new SimpleFieldMetadata(REQUEST, COUNT, COUNT.reference(), "Nombre d'appels", "count"), + new SimpleFieldMetadata(REQUEST, ELAPSEDTIME, ELAPSEDTIME.reference(), "temps de réponse (s)", "s"), + new SimpleFieldMetadata(REQUEST, AVG_ELAPSEDTIME, AVG_ELAPSEDTIME.reference(), "temps de réponse moyen(s)", "s"), + new SimpleFieldMetadata(REQUEST, MAX_ELAPSEDTIME, MAX_ELAPSEDTIME.reference(), "temps de réponse max(s)", "s"), + new SimpleFieldMetadata(REQUEST, MIN_ELAPSEDTIME, MIN_ELAPSEDTIME.reference(), "temps de réponse min(s)", "s"), new CombinedFieldMetadata("nombre d'appels OK / KO", asList( - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, COUNT_STATUS_ERROR, COUNT_STATUS_ERROR.reference(), "nombre d'appels en erreur", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, COUNT_STATUS_SUCCES, COUNT_STATUS_SUCCES.reference(), "nombre d'appels OK", "count"))), + new SimpleFieldMetadata(REQUEST, COUNT_ERROR, COUNT_ERROR.reference(), "nombre d'appels en erreur", "count"), + new SimpleFieldMetadata(REQUEST, COUNT_SUCCES, COUNT_SUCCES.reference(), "nombre d'appels OK", "count"))), new CombinedFieldMetadata("nombre d'appels 2xx/4xx/5xx", asList( - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, COUNT_STATUS_ERROR_CLIENT, COUNT_STATUS_ERROR_CLIENT.reference(), "nombre d'appels en erreur client", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, COUNT_STATUS_ERROR_SERVER, COUNT_STATUS_ERROR_SERVER.reference(), "nombre d'appels en erreur serveur", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, COUNT_STATUS_SUCCES, COUNT_STATUS_SUCCES.reference(), "nombre d'appels OK", "c°"))), + new SimpleFieldMetadata(REQUEST, COUNT_ERROR_CLIENT, COUNT_ERROR_CLIENT.reference(), "nombre d'appels en erreur client", "count"), + new SimpleFieldMetadata(REQUEST, COUNT_ERROR_SERVER, COUNT_ERROR_SERVER.reference(), "nombre d'appels en erreur serveur", "count"), + new SimpleFieldMetadata(REQUEST, COUNT_SUCCES, COUNT_SUCCES.reference(), "nombre d'appels OK", "c°"))), new CombinedFieldMetadata("nombre d'appels par temps de réponse", asList( - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, COUNT_ELAPSEDTIME_SLOWEST, COUNT_ELAPSEDTIME_SLOWEST.reference(), "temps de réponse les plus lents ", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, COUNT_ELAPSEDTIME_SLOW, COUNT_ELAPSEDTIME_SLOW.reference(), "temps de réponse lent", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, COUNT_ELAPSEDTIME_MEDIUM, COUNT_ELAPSEDTIME_MEDIUM.reference(), "temps de réponse moyen", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, COUNT_ELAPSEDTIME_FAST, COUNT_ELAPSEDTIME_FAST.reference(), "temps de réponse rapide", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, COUNT_ELAPSEDTIME_FASTEST, COUNT_ELAPSEDTIME_FASTEST.reference(), "temps de réponse les plus rapides", "count"))) + new SimpleFieldMetadata(REQUEST, COUNT_SLOWEST, COUNT_SLOWEST.reference(), "temps de réponse les plus lents ", "count"), + new SimpleFieldMetadata(REQUEST, COUNT_SLOW, COUNT_SLOW.reference(), "temps de réponse lent", "count"), + new SimpleFieldMetadata(REQUEST, COUNT_MEDIUM, COUNT_MEDIUM.reference(), "temps de réponse moyen", "count"), + new SimpleFieldMetadata(REQUEST, COUNT_FAST, COUNT_FAST.reference(), "temps de réponse rapide", "count"), + new SimpleFieldMetadata(REQUEST, COUNT_FASTEST, COUNT_FASTEST.reference(), "temps de réponse les plus rapides", "count"))) ); } @@ -54,32 +54,32 @@ List fetch() { List fetchFilters() { return asList( - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, MTH, MTH.reference(), "Methode", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, PROTOCOL, PROTOCOL.reference(), "Protocole", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, HOST, HOST.reference(), "Hôte", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, PORT, PORT.reference(), "Port", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, PATH, PATH.reference(), "Path", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, QUERY, QUERY.reference(), "Query", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, CONTENT_TYPE, CONTENT_TYPE.reference(), "Content-Type", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, AUTH, AUTH.reference(), "Schéma d'authentification", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, STATUS, STATUS.reference(), "Status", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, SIZE_IN, SIZE_IN.reference(), "Taille d'entrée", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, SIZE_OUT, SIZE_OUT.reference(), "Taille de sortie", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, START_DATETIME, START_DATETIME.reference(), "Date de début", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, FINISH_DATETIME, FINISH_DATETIME.reference(), "Date de fin", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, THREAD, THREAD.reference(), "Thread", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, API_NAME, API_NAME.reference(), "Nom d'Api", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, USER, USER.reference(), "Utilisateur", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, APP_NAME, APP_NAME.reference(), "Nom d'application", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, VERSION, VERSION.reference(), "Version", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, ADDRESS, ADDRESS.reference(), "Adresse", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, ENVIRONEMENT, ENVIRONEMENT.reference(), "Environement", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, OS, OS.reference(), "Sytèm d'exploitation", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, RE, RE.reference(), "Environement d'exécution", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, AS_DATE, AS_DATE.reference(), "Format date", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, BY_DAY, BY_DAY.reference(), "Format jour", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, BY_MONTH, BY_MONTH.reference(), "Format mois", "count"), - new SimpleFieldMetadata(INCOMING_REQUEST_TABLE, BY_YEAR, BY_YEAR.reference(), "Format Year", "count") + new SimpleFieldMetadata(REQUEST, METHOD, METHOD.reference(), "Methode", "count"), + new SimpleFieldMetadata(REQUEST, PROTOCOL, PROTOCOL.reference(), "Protocole", "count"), + new SimpleFieldMetadata(REQUEST, HOST, HOST.reference(), "Hôte", "count"), + new SimpleFieldMetadata(REQUEST, PORT, PORT.reference(), "Port", "count"), + new SimpleFieldMetadata(REQUEST, PATH, PATH.reference(), "Path", "count"), + new SimpleFieldMetadata(REQUEST, QUERY, QUERY.reference(), "Query", "count"), + new SimpleFieldMetadata(REQUEST, MEDIA, MEDIA.reference(), "Content-Type", "count"), + new SimpleFieldMetadata(REQUEST, AUTH, AUTH.reference(), "Schéma d'authentification", "count"), + new SimpleFieldMetadata(REQUEST, STATUS, STATUS.reference(), "Status", "count"), + new SimpleFieldMetadata(REQUEST, SIZE_IN, SIZE_IN.reference(), "Taille d'entrée", "count"), + new SimpleFieldMetadata(REQUEST, SIZE_OUT, SIZE_OUT.reference(), "Taille de sortie", "count"), + new SimpleFieldMetadata(REQUEST, START, START.reference(), "Date de début", "count"), + new SimpleFieldMetadata(REQUEST, END, END.reference(), "Date de fin", "count"), + new SimpleFieldMetadata(REQUEST, THREAD, THREAD.reference(), "Thread", "count"), + new SimpleFieldMetadata(REQUEST, API_NAME, API_NAME.reference(), "Nom d'Api", "count"), + new SimpleFieldMetadata(REQUEST, USER, USER.reference(), "Utilisateur", "count"), + new SimpleFieldMetadata(REQUEST, APP_NAME, APP_NAME.reference(), "Nom d'application", "count"), + new SimpleFieldMetadata(REQUEST, VERSION, VERSION.reference(), "Version", "count"), + new SimpleFieldMetadata(REQUEST, ADDRESS, ADDRESS.reference(), "Adresse", "count"), + new SimpleFieldMetadata(REQUEST, ENVIRONEMENT, ENVIRONEMENT.reference(), "Environement", "count"), + new SimpleFieldMetadata(REQUEST, OS, OS.reference(), "Sytèm d'exploitation", "count"), + new SimpleFieldMetadata(REQUEST, RE, RE.reference(), "Environement d'exécution", "count"), + new SimpleFieldMetadata(REQUEST, AS_DATE, AS_DATE.reference(), "Format date", "count"), + new SimpleFieldMetadata(REQUEST, BY_DAY, BY_DAY.reference(), "Format jour", "count"), + new SimpleFieldMetadata(REQUEST, BY_MONTH, BY_MONTH.reference(), "Format mois", "count"), + new SimpleFieldMetadata(REQUEST, BY_YEAR, BY_YEAR.reference(), "Format Year", "count") ); } } diff --git a/src/main/java/org/usf/trace/api/server/PerformanceStatsController.java b/src/main/java/org/usf/trace/api/server/PerformanceStatsController.java index 4dbf159a..9725b482 100644 --- a/src/main/java/org/usf/trace/api/server/PerformanceStatsController.java +++ b/src/main/java/org/usf/trace/api/server/PerformanceStatsController.java @@ -1,39 +1,49 @@ package org.usf.trace.api.server; -import lombok.RequiredArgsConstructor; +import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE; +import static org.springframework.http.MediaType.TEXT_HTML_VALUE; +import static org.springframework.http.MediaType.TEXT_PLAIN_VALUE; + +import java.io.IOException; +import java.util.List; + +import javax.servlet.http.HttpServletResponse; + +import org.springframework.http.MediaType; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.web.bind.annotation.CrossOrigin; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RestController; import org.usf.jquery.core.DynamicModel; -import org.usf.jquery.core.ParametredQuery; -import org.usf.jquery.core.RequestQuery; +import org.usf.jquery.core.RequestQueryBuilder; import org.usf.jquery.web.RequestQueryParam; -import java.util.List; - -import static java.util.Collections.emptyList; -import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE; +import lombok.RequiredArgsConstructor; @CrossOrigin @RestController -@RequestMapping(value = "stat", produces = APPLICATION_JSON_VALUE) +@RequestMapping(value = "stat") @RequiredArgsConstructor public class PerformanceStatsController { - private final JdbcTemplate template; - @GetMapping("incoming/request") + @GetMapping(value="incoming/request", produces = APPLICATION_JSON_VALUE) public List stats( - @RequestQueryParam(name = "INCOMING_REQUEST_TABLE", defaultColumns = "STATUS") RequestQuery query) { - return query.execute(this::usingSpringJdbc); + @RequestQueryParam(name = "request", defaultColumns = "count") RequestQueryBuilder query) { + return usingSpringJdbc(query); + } + + @GetMapping(value="session", produces = APPLICATION_JSON_VALUE) + public List session( + @RequestQueryParam(name = "session", defaultColumns = "count") RequestQueryBuilder query) { + return usingSpringJdbc(query); } - private List usingSpringJdbc(ParametredQuery query) { - return query.hasNoResult() - ? emptyList() - : template.query(query.getQuery(), query::mapRows, query.getParams()); + private List usingSpringJdbc(RequestQueryBuilder req) { + var query = req.build(); + return template.query(query.getQuery(), query.defaultMapper()::map, query.getParams()); } } diff --git a/src/main/java/org/usf/trace/api/server/RequestDao.java b/src/main/java/org/usf/trace/api/server/RequestDao.java index 0fef996d..5c661097 100644 --- a/src/main/java/org/usf/trace/api/server/RequestDao.java +++ b/src/main/java/org/usf/trace/api/server/RequestDao.java @@ -8,26 +8,27 @@ import static java.util.function.Function.identity; import static java.util.stream.Collectors.toList; import static java.util.stream.Collectors.toMap; +import static org.usf.trace.api.server.Filters.*; import static org.usf.trace.api.server.Utils.isEmpty; import static org.usf.trace.api.server.Utils.nArg; import static org.usf.trace.api.server.Utils.newArray; import java.sql.Timestamp; import java.time.Instant; -import java.util.Collection; -import java.util.List; -import java.util.Set; +import java.util.*; import java.util.concurrent.atomic.AtomicLong; import java.util.function.BiFunction; import java.util.function.Consumer; import java.util.function.Function; import java.util.stream.Stream; +import com.sun.tools.javac.Main; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Repository; import org.springframework.transaction.annotation.Transactional; import org.usf.traceapi.core.*; + import lombok.Getter; import lombok.RequiredArgsConstructor; import lombok.Setter; @@ -39,6 +40,7 @@ public class RequestDao { private final JdbcTemplate template; + @Transactional(rollbackFor = Exception.class) public void saveSessions(List sessions) { filterAndSave(sessions, IncomingRequest.class, this::addIncomingRequest); @@ -189,6 +191,45 @@ public OutcomingRequest getOutcomingRequestById(String id) { }); } + public List getMainRequestByCriteria(boolean lazy, FilterCriteria fc) { + var query = "SELECT ID_MAIN_REQ,VA_NAME,VA_USR,DH_DBT,DH_FIN,LNCH,LOC,VA_THRED,VA_APP_NME,VA_VRS,VA_ADRS,VA_ENV,VA_OS,VA_RE,VA_ERR_CLS,VA_ERR_MSG FROM E_MAIN_REQ"; + + Collection argTypes = new ArrayList<>(); + Collection args = new ArrayList<>(); + query += fc.toSql(ID_IN_REQ,ID_MAIN_REQ,VA_APP_NME,VA_ENV,CD_PRT,LNCH,DH_DBT,DH_FIN,args,argTypes); + + + List res = template.query(query, args.toArray() , argTypes.stream().mapToInt(i -> i).toArray(),(rs, i) -> { + MainRequest main = new MainRequest(rs.getString("ID_MAIN_REQ")); + main.setName(rs.getString("VA_NAME")); + main.setUser(rs.getString("VA_USR")); + main.setStart(fromNullableTimestamp(rs.getTimestamp("DH_DBT"))); + main.setEnd(fromNullableTimestamp(rs.getTimestamp("DH_FIN"))); + main.setLaunchMode(valueOfNullable(LaunchMode.class, rs.getString("LNCH"))); + main.setLocation(rs.getString("LOC")); + main.setThreadName(rs.getString("VA_THRED")); + main.setApplication(new ApplicationInfo( + rs.getString("VA_APP_NME"), + rs.getString("VA_VRS"), + rs.getString("VA_ADRS"), + rs.getString("VA_ENV"), + rs.getString("VA_OS"), + rs.getString("VA_RE") + )); + main.setException(new ExceptionInfo( + rs.getString("VA_ERR_CLS"), + rs.getString("VA_ERR_MSG") + )); + return main; + }); + if(lazy && !res.isEmpty()) { + var reqMap = res.stream().collect(toMap(MainRequest::getId, identity())); + outcomingRequests(reqMap.keySet()).forEach(r-> reqMap.get(r.getParentId()).getRequests().add(r.getRequest())); + outcomingQueries(reqMap.keySet()).forEach(q-> reqMap.get(q.getParentId()).getQueries().add(q.getQuery())); + } + return res; + } + public List getMainRequestById(boolean lazy, String... idArr) { var query = "SELECT ID_MAIN_REQ,VA_NAME,VA_USR,DH_DBT,DH_FIN,LNCH,LOC,VA_THRED,VA_APP_NME,VA_VRS,VA_ADRS,VA_ENV,VA_OS,VA_RE,VA_ERR_CLS,VA_ERR_MSG FROM E_MAIN_REQ"; int[] argTypes = null; @@ -196,6 +237,7 @@ public List getMainRequestById(boolean lazy, String... idArr) { query += " WHERE ID_MAIN_REQ IN(" + nArg(idArr.length) + ")"; argTypes = newArray(idArr.length, VARCHAR); } + query += " order by DH_DBT desc"; List res = template.query(query, idArr, argTypes, (rs, i) -> { MainRequest main = new MainRequest(rs.getString("ID_MAIN_REQ")); main.setName(rs.getString("VA_NAME")); @@ -226,6 +268,53 @@ public List getMainRequestById(boolean lazy, String... idArr) { } return res; } + + public List getIncomingRequestByCriteria(boolean lazy, FilterCriteria fs) { + var query = "SELECT ID_IN_REQ,VA_MTH,VA_PRTCL,VA_HST,CD_PRT,VA_PTH,VA_QRY,VA_CNT_TYP,VA_AUTH,CD_STT,VA_I_SZE,VA_O_SZE,DH_DBT,DH_FIN,VA_THRED,VA_ERR_CLS,VA_ERR_MSG,VA_API_NME,VA_USR,VA_APP_NME,VA_VRS,VA_ADRS,VA_ENV,VA_OS,VA_RE FROM E_IN_REQ "; + + Collection argTypes = new ArrayList<>(); + Collection args = new ArrayList<>(); + query += fs.toSql(ID_IN_REQ,ID_MAIN_REQ,VA_APP_NME,VA_ENV,CD_PRT,LNCH,DH_DBT,DH_FIN,args,argTypes); + query += " order by DH_DBT desc"; + List res = template.query(query, args.toArray() , argTypes.stream().mapToInt(i -> i).toArray() , (rs, i) -> { + IncomingRequest in = new IncomingRequest(rs.getString("ID_IN_REQ")); + in.setMethod(rs.getString("VA_MTH")); + in.setProtocol(rs.getString("VA_PRTCL")); + in.setHost(rs.getString("VA_HST")); + in.setPort(rs.getInt("CD_PRT")); + in.setPath(rs.getString("VA_PTH")); + in.setQuery(rs.getString("VA_QRY")); + in.setContentType((rs.getString("VA_CNT_TYP"))); + in.setAuthScheme((rs.getString("VA_AUTH"))); + in.setStatus(rs.getInt("CD_STT")); + in.setInDataSize(rs.getLong("VA_I_SZE")); + in.setOutDataSize(rs.getLong("VA_I_SZE")); + in.setStart(fromNullableTimestamp(rs.getTimestamp("DH_DBT"))); + in.setEnd(fromNullableTimestamp(rs.getTimestamp("DH_FIN"))); + in.setThreadName(rs.getString("VA_THRED")); + in.setException(new ExceptionInfo( + rs.getString("VA_ERR_CLS"), + rs.getString("VA_ERR_MSG") + )); + in.setName(rs.getString("VA_API_NME")); + in.setUser(rs.getString("VA_USR")); + in.setApplication(new ApplicationInfo( + rs.getString("VA_APP_NME"), + rs.getString("VA_VRS"), + rs.getString("VA_ADRS"), + rs.getString("VA_ENV"), + rs.getString("VA_OS"), + rs.getString("VA_RE") + )); + return in; + }); + if(lazy && !res.isEmpty()) { + var reqMap = res.stream().collect(toMap(IncomingRequest::getId, identity())); + outcomingRequests(reqMap.keySet()).forEach(r-> reqMap.get(r.getParentId()).getRequests().add(r.getRequest())); + outcomingQueries(reqMap.keySet()).forEach(q-> reqMap.get(q.getParentId()).getQueries().add(q.getQuery())); + } + return res; + } public List getIncomingRequestById(boolean lazy, String... idArr) { var query = "SELECT ID_IN_REQ,VA_MTH,VA_PRTCL,VA_HST,CD_PRT,VA_PTH,VA_QRY,VA_CNT_TYP,VA_AUTH,CD_STT,VA_I_SZE,VA_O_SZE,DH_DBT,DH_FIN,VA_THRED,VA_ERR_CLS,VA_ERR_MSG,VA_API_NME,VA_USR,VA_APP_NME,VA_VRS,VA_ADRS,VA_ENV,VA_OS,VA_RE FROM E_IN_REQ"; int[] argTypes = null; @@ -233,6 +322,7 @@ public List getIncomingRequestById(boolean lazy, String... idAr query += " WHERE ID_IN_REQ IN(" + nArg(idArr.length) + ")"; argTypes = newArray(idArr.length, VARCHAR); } + List res = template.query(query, idArr, argTypes, (rs, i) -> { IncomingRequest in = new IncomingRequest(rs.getString("ID_IN_REQ")); in.setMethod(rs.getString("VA_MTH")); @@ -275,7 +365,7 @@ public List getIncomingRequestById(boolean lazy, String... idAr public List outcomingRequests(Set incomingId) { //use criteria var query = "SELECT ID_OUT_REQ,VA_PRTCL,VA_HST,CD_PRT,VA_PTH,VA_QRY,VA_MTH,CD_STT,VA_I_SZE,VA_O_SZE,DH_DBT,DH_FIN,VA_THRED,VA_ERR_CLS,VA_ERR_MSG,CD_IN_REQ FROM E_OUT_REQ" - + " WHERE CD_IN_REQ IN(" + nArg(incomingId.size()) + ")"; + + " WHERE CD_IN_REQ IN(" + nArg(incomingId.size()) + ") ORDER BY DH_DBT ASC"; return template.query(query, incomingId.toArray(), newArray(incomingId.size(), VARCHAR), (rs, i) -> { OutcomingRequestWrapper out = new OutcomingRequestWrapper(rs.getString("ID_OUT_REQ"), rs.getString("CD_IN_REQ")); out.setProtocol(rs.getString("VA_PRTCL")); @@ -326,7 +416,7 @@ public List outcomingQueries(Set incomingId) { // public List databaseActions(Set queries) { // non empty var query = "SELECT VA_TYP,DH_DBT,DH_FIN,VA_ERR_CLS,VA_ERR_MSG,CD_OUT_QRY FROM E_DB_ACT" - + " WHERE CD_OUT_QRY IN(" + nArg(queries.size()) + ")"; + + " WHERE CD_OUT_QRY IN(" + nArg(queries.size()) + ") ORDER BY DH_DBT ASC"; return template.query(query, queries.toArray(), newArray(queries.size(), BIGINT), (rs, i)-> new DatabaseActionWrapper( rs.getLong("CD_OUT_QRY"), @@ -436,4 +526,6 @@ private static > T valueOfNullable(Class classe, String val .flatMap(v-> Stream.of(classe.getEnumConstants()).filter(e-> e.name().equals(v)).findAny()) .orElse(null); } -} \ No newline at end of file +} + + diff --git a/src/main/java/org/usf/trace/api/server/WebmvcConfig.java b/src/main/java/org/usf/trace/api/server/WebmvcConfig.java index f399049e..56c0d40c 100644 --- a/src/main/java/org/usf/trace/api/server/WebmvcConfig.java +++ b/src/main/java/org/usf/trace/api/server/WebmvcConfig.java @@ -1,7 +1,7 @@ package org.usf.trace.api.server; import static java.util.Arrays.asList; -import static org.usf.jquery.web.DatabaseScanner.configure; +import static org.usf.jquery.web.JQueryContext.register; import java.util.List; @@ -21,14 +21,12 @@ public class WebmvcConfig implements WebMvcConfigurer { private final DataSource ds; - private String schema = null; - @Override public void addArgumentResolvers(List resolvers) { - configure(schema, ds) - .register(asList(TraceApiTable.values()), - asList(TraceApiColumn.values())) - .fetch(); //refresh first ? + register(asList(TraceApiTable.values()), + asList(TraceApiColumn.values())) + .bind(ds) + .fetch(); //refresh first ? resolvers.add(new CommonRequestQueryResolver()); } } diff --git a/src/main/java/org/usf/trace/api/server/config/DataConstants.java b/src/main/java/org/usf/trace/api/server/config/DataConstants.java index e3f4e96e..84f4cb2a 100644 --- a/src/main/java/org/usf/trace/api/server/config/DataConstants.java +++ b/src/main/java/org/usf/trace/api/server/config/DataConstants.java @@ -3,7 +3,6 @@ import org.usf.jquery.core.ComparisonExpression; import org.usf.jquery.core.DBColumn; import org.usf.jquery.core.OperationColumn; -import org.usf.jquery.web.ColumnDecorator; import org.usf.jquery.web.TableDecorator; import lombok.AccessLevel; @@ -12,64 +11,113 @@ import java.sql.Timestamp; import java.time.Instant; -import static org.usf.jquery.core.DBComparator.*; -import static org.usf.jquery.core.DBFunction.*; +import static org.usf.jquery.core.ComparisonExpression.*; +import static org.usf.jquery.core.DBColumn.*; import static org.usf.trace.api.server.config.TraceApiColumn.STATUS; @NoArgsConstructor(access = AccessLevel.PRIVATE) public final class DataConstants { + + public static String sessionColumns(TraceApiColumn column) { + switch (column) { + case ID: return "id_main_req"; + case NAME: return "va_name"; + case START: return "dh_dbt"; + case END: return "dh_fin"; + case USER: return "va_usr"; + case OS: return "va_os"; + case RE: return "va_re"; + case TYPE: return "lnch"; + case LOCATION: return "loc"; + case THREAD: return "va_thred"; + case APP_NAME: return "va_app_nme"; + case VERSION: return "va_vrs"; + case ADDRESS: return "va_adrs"; + case ENVIRONEMENT: return "va_env"; + case ERR_TYPE: return "va_err_cls"; + case ERR_MSG: return "va_err_msg"; + default: return null; + } + } - public static String incReqColumns(TraceApiColumn incomingRequest) { - switch (incomingRequest) { - case ID_INCOMING_REQ: - return "ID_IN_REQ"; - case MTH: - return "VA_MTH"; - case PROTOCOL: - return "VA_PRTCL"; - case HOST: - return "VA_HST"; - case PORT: - return "CD_PRT"; - case PATH: - return "VA_PTH"; - case QUERY: - return "VA_QRY"; - case CONTENT_TYPE: - return "VA_CNT_TYP"; - case AUTH: - return "VA_AUTH"; - case STATUS: - return "CD_STT"; - case SIZE_IN: - return "VA_I_SZE"; - case SIZE_OUT: - return "VA_O_SZE"; - case START_DATETIME: - return "DH_DBT"; - case FINISH_DATETIME: - return "DH_FIN"; - case THREAD: - return "VA_THRED"; - case API_NAME: - return "VA_API_NME"; - case USER: - return "VA_USR"; - case APP_NAME: - return "VA_APP_NME"; - case VERSION: - return "VA_VRS"; - case ADDRESS: - return "VA_ADRS"; - case ENVIRONEMENT: - return "VA_ENV"; - case OS: - return "VA_OS"; - case RE: - return "VA_RE"; + public static String incReqColumns(TraceApiColumn column) { + switch (column) { + case ID: return "id_in_req"; + case METHOD: return "va_mth"; + case PROTOCOL: return "va_prtcl"; + case HOST: return "va_hst"; + case PORT: return "cd_prt"; + case PATH: return "va_pth"; + case QUERY: return "va_qry"; + case MEDIA: return "va_cnt_typ"; + case AUTH: return "va_auth"; + case STATUS: return "cd_stt"; + case SIZE_IN: return "va_i_sze"; + case SIZE_OUT: return "va_o_sze"; + case START: return "dh_dbt"; + case END: return "dh_fin"; + case THREAD: return "va_thred"; + case API_NAME: return "va_api_nme"; + case USER: return "va_usr"; + case APP_NAME: return "va_app_nme"; + case VERSION: return "va_vrs"; + case ADDRESS: return "va_adrs"; + case ENVIRONEMENT: return "va_env"; + case OS: return "va_os"; + case RE: return "va_re"; + default: return null; + } + } + + public static String outReqColumns(TraceApiColumn column) { + switch (column) { + case ID: return "id_out_req"; + case METHOD: return "va_mth"; + case PROTOCOL: return "va_prtcl"; + case HOST: return "va_hst"; + case PORT: return "cd_prt"; + case PATH: return "va_pth"; + case QUERY: return "va_qry"; + case MEDIA: return "va_cnt_typ"; + case AUTH: return "va_auth"; + case STATUS: return "cd_stt"; + case SIZE_IN: return "va_i_sze"; + case SIZE_OUT: return "va_o_sze"; + case START: return "dh_dbt"; + case END: return "dh_fin"; + case THREAD: return "va_thred"; + case PARENT: return "cd_in_req"; + default: return null; + } + } + public static String outQryColumns(TraceApiColumn column) { + switch (column){ + case ID: return "id_out_qry"; + case HOST: return "va_hst"; + case PORT: return "cd_prt"; + case SCHEMA: return "va_schma"; + case START: return "dh_dbt"; + case END: return "dh_fin"; + case USER: return "va_usr"; + case THREAD: return "va_thred"; + case DRIVER: return "va_drv"; + case DB_NAME: return "va_db_nme"; + case DB_VERSION: return "va_db_vrs"; + case COMPLETE: return "va_cmplt"; + case PARENT: return "cd_in_req"; + default: return null; + } + } - default: - throw undeclaredColumn(incomingRequest); + public static String dbActColumns(TraceApiColumn column){ + switch (column){ + case TYPE: return"va_typ"; + case START: return "dh_dbt"; + case END: return "dh_fin"; + case ERR_TYPE: return "va_err_cls"; + case ERR_MSG: return "va_err_msg"; + case PARENT: return "cd_out_qry"; + default: return null; } } @@ -81,10 +129,12 @@ public static DBColumn asDate_Tera(TableDecorator table) { return c -> "(CAST(DH_DBT AS DATE))"; } + @Deprecated(forRemoval = true) public static ComparisonExpression greaterOrEqualsExpressions(String timestamp) { return greaterOrEqual(Timestamp.from(Instant.parse(timestamp))); } + @Deprecated(forRemoval = true) public static ComparisonExpression lessThanExpressions(String timestamp) { return lessThan(Timestamp.from(Instant.parse(timestamp))); } @@ -94,6 +144,10 @@ public static DBColumn elapsedtime(TableDecorator table) { return c -> "CAST(TIMESTAMPDIFF(MILLISECOND, DH_DBT, DH_FIN) /1000.0 AS DECIMAL(10,2))"; } + public static DBColumn elapsedtime2(TableDecorator table) { + return c -> "extract(EPOCH from (dh_fin - dh_dbt))"; + } + public static DBColumn asDate(TableDecorator table) { return c -> "FORMATDATETIME (DH_DBT, 'yyyy-MM-dd' )"; } @@ -127,7 +181,7 @@ public static OperationColumn maxElapsedTime(TableDecorator table) { } private static OperationColumn countStatusByType(TableDecorator table, ComparisonExpression op) { - var status = STATUS.column(table); + var status = table.column(STATUS); return count((status).when(op).then(status).end()); } @@ -155,6 +209,10 @@ public static OperationColumn countStatus404(TableDecorator table) { public static OperationColumn countStatus500(TableDecorator table) { return countStatusByType(table, equal(500)); } + + public static OperationColumn countStatus503(TableDecorator table) { + return countStatusByType(table, equal(503)); + } public static OperationColumn countErrorStatus(TableDecorator table) { return countStatusByType(table, greaterOrEqual(400)); @@ -169,11 +227,7 @@ public static OperationColumn countServerErrorStatus(TableDecorator table) { } public static OperationColumn countSuccesStatus(TableDecorator table) { - return countStatusByType(table, greaterOrEqual(200).and(lessOrEqual(226))); - } - - private static RuntimeException undeclaredColumn(ColumnDecorator column) { - return new IllegalArgumentException("unknown column " + column); + return countStatusByType(table, greaterOrEqual(200).and(lessThan(300))); } public static ComparisonExpression elapsedTimeExpressions(String name) { @@ -194,7 +248,7 @@ public static ComparisonExpression elapsedTimeExpressions(String name) { } private static OperationColumn elapsedTimeBySpeed(ComparisonExpression op, TableDecorator table) { - var elapsed = elapsedtime(table); + var elapsed = elapsedtime2(table); return count(elapsed.when(op).then(elapsed).end()); } diff --git a/src/main/java/org/usf/trace/api/server/config/TraceApiColumn.java b/src/main/java/org/usf/trace/api/server/config/TraceApiColumn.java index 3ed61ffd..f7c13aca 100644 --- a/src/main/java/org/usf/trace/api/server/config/TraceApiColumn.java +++ b/src/main/java/org/usf/trace/api/server/config/TraceApiColumn.java @@ -1,98 +1,112 @@ package org.usf.trace.api.server.config; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; -import org.usf.jquery.core.ComparisonExpression; +import static java.util.Objects.nonNull; +import static java.util.Objects.requireNonNullElseGet; + +import java.util.Objects; + import org.usf.jquery.core.DBColumn; -import org.usf.jquery.core.TaggableColumn; -import org.usf.jquery.web.ArgumentParser; +import org.usf.jquery.web.ColumnBuilder; import org.usf.jquery.web.ColumnDecorator; -import org.usf.jquery.web.TableDecorator; -import org.usf.jquery.web.TableMetadata; - -import java.sql.Date; -import java.time.LocalDate; -import java.util.ArrayList; -import java.util.function.Function; +import org.usf.jquery.web.CriteriaBuilder; -import static org.usf.jquery.core.DBFunction.count; +import lombok.NonNull; +import lombok.RequiredArgsConstructor; @RequiredArgsConstructor public enum TraceApiColumn implements ColumnDecorator { - ID_INCOMING_REQ("idIncomingRequest"), - MTH("mth"), + ID("id"), + METHOD("method"), //METHOD PROTOCOL("protocol"), HOST("host"), PORT("port"), PATH("path"), QUERY("query"), - CONTENT_TYPE("contentType"), + MEDIA("contentType"), //mime | media type AUTH("auth"), STATUS("status"), SIZE_IN("sizeIn"), SIZE_OUT("sizeOut"), - START_DATETIME("startDatetime", null, DataConstants::greaterOrEqualsExpressions), - FINISH_DATETIME("finishDatetime", null, DataConstants::lessThanExpressions), + START("start", null, DataConstants::greaterOrEqualsExpressions),//@see gt, lt, .. //start + END("end", null, DataConstants::lessThanExpressions), //end THREAD("thread"), - API_NAME("apiName"), + API_NAME("apiName"), //API + APP_NAME("appName"), //APP USER("user"), - APP_NAME("appName"), VERSION("version"), ADDRESS("address"), - ENVIRONEMENT("environement"), + ENVIRONEMENT("environement"), //ENV OS("os"), RE("re"), - - - - + + NAME("name"), + TYPE("type"), + LOCATION("location"), + ERR_TYPE("errorType"), + ERR_MSG("errorMessage"), + + SCHEMA("schema"), + DRIVER("driver"), + DB_NAME("dbName"), + DB_VERSION("dbVersion"), + COMPLETE ("complete"), + PARENT("parent"), //--- - AS_DATE("asDate", DataConstants::asDate), - BY_DAY("byDay", DataConstants::byDay), - - BY_MONTH("byMonth", DataConstants::byMonth), - BY_YEAR("byYear", DataConstants::byYear), - ELAPSEDTIME("elapsedtime", DataConstants::elapsedtime, DataConstants::elapsedTimeExpressions), - AVG_ELAPSEDTIME("avgElapsedTime", DataConstants::avgElapsedTime), - MAX_ELAPSEDTIME("maxElapsedTime", DataConstants::maxElapsedTime), - MIN_ELAPSEDTIME("minElapsedTime", DataConstants::minElapsedTime), - - COUNT_ELAPSEDTIME_SLOWEST("elapsedTimeSlowest", DataConstants::elapsedTimeVerySlow), - COUNT_ELAPSEDTIME_SLOW("elapsedTimeSlow", DataConstants::elapsedTimeSlow), - COUNT_ELAPSEDTIME_MEDIUM("elapsedTimeMedium", DataConstants::elapsedTimeMedium), - COUNT_ELAPSEDTIME_FAST("elapsedTimeFast", DataConstants::elapsedTimeFast), - COUNT_ELAPSEDTIME_FASTEST("elapsedTimeFastest", DataConstants::elapsedTimeFastest), - COUNT("countRows", t -> count(), DataConstants::elapsedTimeExpressions), - COUNT_STATUS_ERROR("countErrorRows", DataConstants::countErrorStatus), - - COUNT_STATUS_ERROR_CLIENT("countClientErrorRows", DataConstants::countClientErrorStatus), - COUNT_STATUS_ERROR_SERVER("countServerErrorRows", DataConstants::countServerErrorStatus), - COUNT_STATUS_SUCCES("countSuccesRows", DataConstants::countSuccesStatus), - COUNT_200("count200", DataConstants::countStatus200), + @Deprecated(forRemoval = true) + AS_DATE("asDate", DataConstants::asDate), //start.date + @Deprecated(forRemoval = true) + BY_DAY("byDay", DataConstants::byDay), //start.day + + @Deprecated(forRemoval = true) + BY_MONTH("byMonth", DataConstants::byMonth), //start.month + @Deprecated(forRemoval = true) + BY_YEAR("byYear", DataConstants::byYear), //start.year + ELAPSEDTIME("elapsedtime", DataConstants::elapsedtime2, DataConstants::elapsedTimeExpressions), + @Deprecated(forRemoval = true) + AVG_ELAPSEDTIME("avgElapsedTime", DataConstants::avgElapsedTime), //elapsedtime.avg + @Deprecated(forRemoval = true) + MAX_ELAPSEDTIME("maxElapsedTime", DataConstants::maxElapsedTime), //elapsedtime.max + @Deprecated(forRemoval = true) + MIN_ELAPSEDTIME("minElapsedTime", DataConstants::minElapsedTime), //elapsedtime.min + + COUNT_SLOWEST("elapsedTimeSlowest", DataConstants::elapsedTimeVerySlow), + COUNT_SLOW("elapsedTimeSlow", DataConstants::elapsedTimeSlow), + COUNT_MEDIUM("elapsedTimeMedium", DataConstants::elapsedTimeMedium), + COUNT_FAST("elapsedTimeFast", DataConstants::elapsedTimeFast), + COUNT_FASTEST("elapsedTimeFastest", DataConstants::elapsedTimeFastest), + @Deprecated(forRemoval = true) + COUNT("countRows", t-> DBColumn.count(), DataConstants::elapsedTimeExpressions), //use count funct + COUNT_ERROR("countErrorRows", DataConstants::countErrorStatus), + + COUNT_ERROR_CLIENT("countClientErrorRows", DataConstants::countClientErrorStatus), + COUNT_ERROR_SERVER("countServerErrorRows", DataConstants::countServerErrorStatus), + COUNT_SUCCES("countSuccesRows", DataConstants::countSuccesStatus), + COUNT_200("count200", DataConstants::countStatus200), //set type improve perf COUNT_400("count400", DataConstants::countStatus400), COUNT_401("count401", DataConstants::countStatus401), COUNT_403("count403", DataConstants::countStatus403), COUNT_404("count404", DataConstants::countStatus404), - COUNT_500("count500", DataConstants::countStatus500); + COUNT_500("count500", DataConstants::countStatus500), + COUNT_503("count503", DataConstants::countStatus503); private final String out; //nullable - private final Function columnTemplate; - private final Function expressionFn; + private final ColumnBuilder columnTemplate; + private final CriteriaBuilder expressionFn; private TraceApiColumn(@NonNull String tagname) { this(tagname, null, null); } - private TraceApiColumn(@NonNull String tagname, @NonNull Function columnTemplate) { + private TraceApiColumn(@NonNull String tagname, @NonNull ColumnBuilder columnTemplate) { this(tagname, columnTemplate, null); } @Override public String identity() { - return this.name(); + return this.name().toLowerCase(); } @Override @@ -101,11 +115,20 @@ public String reference() { } @Override - public TaggableColumn column(TableDecorator table) { - return columnTemplate == null - ? ColumnDecorator.super.column(table) - : columnTemplate.apply(table).as(out); + public ColumnBuilder builder() { + return nonNull(columnTemplate) + ? columnTemplate + : ColumnDecorator.super.builder(); + } + + @Override + public CriteriaBuilder criteria(String name) { + + return "group".equals(name) && nonNull(expressionFn) //TODO rename group + ? expressionFn + : ColumnDecorator.super.criteria(name); } + /*@Override public DBFilter filter(TableDecorator table, TableMetadata meta, String... values) { System.out.println("-------------"+values.toString()); @@ -126,36 +149,36 @@ public DBFilter filter(TableDecorator table, TableMetadata meta, String... value }*/ - @Override - public ComparisonExpression expression(TableMetadata cm, String... values) { - if (expressionFn != null) { - var list = new ArrayList(values.length); - for (var v : values) { - var exp = expressionFn.apply(v); - if (exp == null) { - break; - } - list.add(exp); - } - if (list.size() == values.length) { // all values or not - return list.stream().reduce(ComparisonExpression::or).orElseThrow(); - } - } - return ColumnDecorator.super.expression(cm, values); - } - - - @Override - public ArgumentParser parser(TableMetadata metadata) { - if (this == COUNT) { - return Integer::parseInt; - } - if (this == BY_DAY || this == BY_YEAR || this == BY_MONTH) { - return Integer::parseInt; - } - if (this == AS_DATE) { - return v -> Date.valueOf(LocalDate.parse(v)); - } - return ColumnDecorator.super.parser(metadata); - } +// @Override +// public ComparisonExpression expression(TableMetadata cm, String... values) { +// if (expressionFn != null) { +// var list = new ArrayList(values.length); +// for (var v : values) { +// var exp = expressionFn.apply(v); +// if (exp == null) { +// break; +// } +// list.add(exp); +// } +// if (list.size() == values.length) { // all values or not +// return list.stream().reduce(ComparisonExpression::or).orElseThrow(); +// } +// } +// return ColumnDecorator.super.expression(cm, values); +// } + + +// @Override +// public ArgumentParser parser(TableMetadata metadata) { +// if (this == COUNT) { +// return Integer::parseInt; +// } +// if (this == BY_DAY || this == BY_YEAR || this == BY_MONTH) { +// return Integer::parseInt; +// } +// if (this == AS_DATE) { +// return v -> Date.valueOf(LocalDate.parse(v)); +// } +// return ColumnDecorator.super.parser(metadata); +// } } diff --git a/src/main/java/org/usf/trace/api/server/config/TraceApiTable.java b/src/main/java/org/usf/trace/api/server/config/TraceApiTable.java index 242f1dd0..6dd0e283 100644 --- a/src/main/java/org/usf/trace/api/server/config/TraceApiTable.java +++ b/src/main/java/org/usf/trace/api/server/config/TraceApiTable.java @@ -1,17 +1,24 @@ package org.usf.trace.api.server.config; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; +import static java.util.Optional.ofNullable; + +import java.util.Optional; +import java.util.function.Function; + import org.usf.jquery.web.ColumnDecorator; import org.usf.jquery.web.TableDecorator; -import java.util.function.Function; +import lombok.NonNull; +import lombok.RequiredArgsConstructor; @RequiredArgsConstructor public enum TraceApiTable implements TableDecorator { - - INCOMING_REQUEST_TABLE("E_IN_REQ", DataConstants::incReqColumns); + OUT("e_out_req", DataConstants::outReqColumns), + REQUEST("e_in_req", DataConstants::incReqColumns), + SESSION("e_main_req", DataConstants::sessionColumns), + QUERY("e_out_qry",DataConstants::outQryColumns), + DBACTION("e_db_act",DataConstants::dbActColumns); @NonNull private final String tableName; @@ -20,21 +27,16 @@ public enum TraceApiTable implements TableDecorator { @Override public String identity() { - return name(); + return name().toLowerCase(); } @Override - public String reference() { - return tableName; + public Optional columnName(ColumnDecorator desc) { + return ofNullable(columnMap.apply((TraceApiColumn) desc)); } - @Override - public String columnName(ColumnDecorator desc) { - return columnMap.apply((TraceApiColumn) desc); - } - - @Override - public String sql() { - return tableName; - } + @Override + public String tableName() { + return tableName; + } }